<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  
  
  <meta name="description" content="python_interview
Python基础

Python语言基本
1.列出 5 个常用 Python 标准库?
2.Python的内建数据类型有哪些?
3.简述 with 方法打开处理文件帮我我们做了什么？
4.Python的可变和不可变数据类型？
5.Python 获取当前日期？
6.谈" />
  

  
  
  
  
  
  
  <title>python基础理论宝典 | 南辞的技术博客</title>
  <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
  <meta name="description" content="python_interview Python基础  Python语言基本 1.列出 5 个常用 Python 标准库? 2.Python的内建数据类型有哪些? 3.简述 with 方法打开处理文件帮我我们做了什么？ 4.Python的可变和不可变数据类型？ 5.Python 获取当前日期？ 6.谈谈对 Python 的了解和其他语言的区别 7.说说你知道的Python3 和 Python2 之间">
<meta property="og:type" content="article">
<meta property="og:title" content="python基础理论宝典">
<meta property="og:url" content="https://yanlidoushikeke.gitee.io/myhexo/2021/04/26/python%E5%9F%BA%E7%A1%80%E7%90%86%E8%AE%BA%E5%AE%9D%E5%85%B8/index.html">
<meta property="og:site_name" content="南辞的技术博客">
<meta property="og:description" content="python_interview Python基础  Python语言基本 1.列出 5 个常用 Python 标准库? 2.Python的内建数据类型有哪些? 3.简述 with 方法打开处理文件帮我我们做了什么？ 4.Python的可变和不可变数据类型？ 5.Python 获取当前日期？ 6.谈谈对 Python 的了解和其他语言的区别 7.说说你知道的Python3 和 Python2 之间">
<meta property="og:locale" content="en_US">
<meta property="og:image" content="c:/Users/%E9%80%B8%E5%8F%AF/Desktop/.gitbook/assets/web-7.jpg">
<meta property="article:published_time" content="2021-04-26T01:38:33.000Z">
<meta property="article:modified_time" content="2021-04-26T13:23:26.243Z">
<meta property="article:author" content="南辞">
<meta name="twitter:card" content="summary">
<meta name="twitter:image" content="c:/Users/%E9%80%B8%E5%8F%AF/Desktop/.gitbook/assets/web-7.jpg">
  
  
    <link rel="icon" href="/tefuir/css/images/favicon.ico">
  
  
<link rel="stylesheet" href="/tefuir/css/style.css">

  

  
  <!-- baidu webmaster push -->
  <script src='//push.zhanzhang.baidu.com/push.js'></script>
<meta name="generator" content="Hexo 5.2.0"><link rel="alternate" href="/tefuir/atom.xml" title="南辞的技术博客" type="application/atom+xml">
</head>
<body class="home blog custom-background custom-font-enabled single-author">
  <div id="page" class="hfeed site">
      <header id="masthead" class="site-header" role="banner">
    <hgroup>
      <h1 class="site-title">
        <a href="/tefuir/" title="南辞的技术博客" rel="home">南辞的技术博客</a>
      </h1>
      
        <h2 class="site-description hitokoto"></h2>
        <script type="text/javascript" src="https://v1.hitokoto.cn/?encode=js"></script>
      
    </hgroup>

    <nav id="site-navigation" class="main-navigation" role="navigation">
            <button class="menu-toggle">菜单</button>
            <a class="assistive-text" href="/#content" title="跳至内容">跳至内容</a><!--TODO-->
            <div class="menu-main-container">
                <ul id="menu-main" class="nav-menu">
                
                    <li class="menu-item menu-item-type-post_type menu-item-object-page"><a href="/tefuir/">Home</a></li>
                
                    <li class="menu-item menu-item-type-post_type menu-item-object-page"><a href="/tefuir/archives">Archives</a></li>
                
                </ul>
            </div>
    </nav>
</header>

      <div id="main" class="wrapper">
        <div id="primary" class="site-content"><div id="content" role="main"><article id="post-python基础理论宝典" class="post-python基础理论宝典 post type-post status-publish format-standard hentry">
    <!---->

      <header class="entry-header">
        
        
  
    <h1 class="entry-title article-title">
      python基础理论宝典
    </h1>
  

        
        <div class="comments-link">
            
            <a href="javascript:void(0);" data-url="https://yanlidoushikeke.gitee.io/myhexo/2021/04/26/python%E5%9F%BA%E7%A1%80%E7%90%86%E8%AE%BA%E5%AE%9D%E5%85%B8/" data-id="cknzsqftq000954u0fejb0xi7" class="leave-reply bdsharebuttonbox" data-cmd="more">Share</a>
        </div><!-- .comments-link -->
      </header><!-- .entry-header -->

    <div class="entry-content">
      
        <h1 id="python-interview"><a href="#python-interview" class="headerlink" title="python_interview"></a>python_interview</h1><ul>
<li><p><a href="python_interview.md#python%E5%9F%BA%E7%A1%80">Python基础</a></p>
<ul>
<li><a href="python_interview.md#python%E8%AF%AD%E8%A8%80%E5%9F%BA%E6%9C%AC">Python语言基本</a><ul>
<li><a href="python_interview.md#1%E5%88%97%E5%87%BA-5-%E4%B8%AA%E5%B8%B8%E7%94%A8-python-%E6%A0%87%E5%87%86%E5%BA%93">1.列出 5 个常用 Python 标准库?</a></li>
<li><a href="python_interview.md#2python%E7%9A%84%E5%86%85%E5%BB%BA%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E6%9C%89%E5%93%AA%E4%BA%9B">2.Python的内建数据类型有哪些?</a></li>
<li><a href="python_interview.md#3%E7%AE%80%E8%BF%B0-with-%E6%96%B9%E6%B3%95%E6%89%93%E5%BC%80%E5%A4%84%E7%90%86%E6%96%87%E4%BB%B6%E5%B8%AE%E6%88%91%E6%88%91%E4%BB%AC%E5%81%9A%E4%BA%86%E4%BB%80%E4%B9%88">3.简述 with 方法打开处理文件帮我我们做了什么？</a></li>
<li><a href="python_interview.md#4python%E7%9A%84%E5%8F%AF%E5%8F%98%E5%92%8C%E4%B8%8D%E5%8F%AF%E5%8F%98%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B">4.Python的可变和不可变数据类型？</a></li>
<li><a href="python_interview.md#5python-%E8%8E%B7%E5%8F%96%E5%BD%93%E5%89%8D%E6%97%A5%E6%9C%9F">5.Python 获取当前日期？</a></li>
<li><a href="python_interview.md#6%E8%B0%88%E8%B0%88%E5%AF%B9-python-%E7%9A%84%E4%BA%86%E8%A7%A3%E5%92%8C%E5%85%B6%E4%BB%96%E8%AF%AD%E8%A8%80%E7%9A%84%E5%8C%BA%E5%88%AB">6.谈谈对 Python 的了解和其他语言的区别</a></li>
<li><a href="python_interview.md#7%E8%AF%B4%E8%AF%B4%E4%BD%A0%E7%9F%A5%E9%81%93%E7%9A%84python3-%E5%92%8C-python2-%E4%B9%8B%E9%97%B4%E7%9A%84%E5%8C%BA%E5%88%AB">7.说说你知道的Python3 和 Python2 之间的区别</a></li>
<li><a href="python_interview.md#8%E4%BA%86%E8%A7%A3-python-%E4%B9%8B%E7%A6%85%E4%B9%88">8.了解 Python 之禅么？</a></li>
<li><a href="python_interview.md#9%E4%BA%86%E8%A7%A3-docstring-%E4%B9%88">9.了解 docstring 么？</a></li>
<li><a href="python_interview.md#10%E4%BA%86%E8%A7%A3%E7%B1%BB%E5%9E%8B%E6%B3%A8%E8%A7%A3%E4%B9%88">10.了解类型注解么？</a></li>
<li><a href="python_interview.md#11%E4%BE%8B%E4%B8%BE%E4%BD%A0%E7%9F%A5%E9%81%93-python-%E5%AF%B9%E8%B1%A1%E7%9A%84%E5%91%BD%E5%90%8D%E8%A7%84%E8%8C%83%E4%BE%8B%E5%A6%82%E6%96%B9%E6%B3%95%E6%88%96%E8%80%85%E7%B1%BB%E7%AD%89">11.例举你知道 Python 对象的命名规范，例如方法或者类等</a></li>
<li><a href="python_interview.md#12%E4%BE%8B%E4%B8%BE%E5%87%A0%E4%B8%AA%E8%A7%84%E8%8C%83-python-%E4%BB%A3%E7%A0%81%E9%A3%8E%E6%A0%BC%E7%9A%84%E5%B7%A5%E5%85%B7">12.例举几个规范 Python 代码风格的工具</a></li>
<li><a href="python_interview.md#13%E4%B8%80%E4%B8%AA%E7%BC%96%E7%A0%81%E4%B8%BA-gbk-%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2-s%E8%A6%81%E5%B0%86%E5%85%B6%E8%BD%AC%E6%88%90-utf-8-%E7%BC%96%E7%A0%81%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%BA%94%E5%A6%82%E4%BD%95%E6%93%8D%E4%BD%9C">13.一个编码为 GBK 的字符串 S，要将其转成 UTF-8 编码的字符串，应如何操作？</a></li>
<li><a href="python_interview.md#14%E7%94%A8%E6%AD%A3%E5%88%99%E5%88%87%E5%88%86%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%8E%BB%E9%99%A4%E9%9D%9E%E7%AC%A6%E5%8F%B7">14.用正则切分字符串去除非符号</a></li>
<li><a href="python_interview.md#15%E5%8D%95%E5%BC%95%E5%8F%B7%E5%8F%8C%E5%BC%95%E5%8F%B7%E4%B8%89%E5%BC%95%E5%8F%B7%E7%9A%84%E5%8C%BA%E5%88%AB">15.单引号、双引号、三引号的区别？</a></li>
<li>[16.[[1,2],[3,4],[5,6]]一行代码展开该列表，得出<a href="python_interview.md#16%5B%5B12%5D%5B34%5D%5B56%5D%5D%E4%B8%80%E8%A1%8C%E4%BB%A3%E7%A0%81%E5%B1%95%E5%BC%80%E8%AF%A5%E5%88%97%E8%A1%A8%E5%BE%97%E5%87%BA%5B123456%5D">1,2,3,4,5,6]</a></li>
<li><a href="python_interview.md#17%E5%93%AA%E4%BA%9B%E4%B8%8D%E8%83%BD%E4%BD%9C%E4%B8%BA%E5%AD%97%E5%85%B8%E7%9A%84%E5%81%A5">17.哪些不能作为字典的健</a></li>
<li>[18.如何交换字典 {“A”：1,”B”：2}的键和值？](#18如何交换字典-“a”：1”b”：2的键和值)</li>
<li><a href="python_interview.md#19%E5%AF%B9%E7%94%9F%E6%88%90%E5%99%A8%E7%B1%BB%E5%9E%8B%E7%9A%84%E5%AF%B9%E8%B1%A1%E5%AE%9E%E7%8E%B0%E5%88%87%E7%89%87%E5%8A%9F%E8%83%BD">19.对生成器类型的对象实现切片功能</a></li>
<li><a href="python_interview.md#20%E5%85%B3%E4%BA%8Elist-tuple-copy-%E5%92%8C-deepcopy-%E7%9A%84%E5%8C%BA%E5%88%AB%E6%98%AF%E4%BB%80%E4%B9%88">20.关于list tuple copy 和 deepcopy 的区别是什么？</a></li>
<li><a href="python_interview.md#21%E4%BB%A3%E7%A0%81%E4%B8%AD%E7%BB%8F%E5%B8%B8%E9%81%87%E5%88%B0%E7%9A%84args-kwargs-%E5%90%AB%E4%B9%89%E5%8F%8A%E7%94%A8%E6%B3%95">21.代码中经常遇到的_args, *_kwargs 含义及用法。</a></li>
<li><a href="python_interview.md#22python-%E4%B8%AD%E4%BC%9A%E6%9C%89%E5%87%BD%E6%95%B0%E6%88%96%E6%88%90%E5%91%98%E5%8F%98%E9%87%8F%E5%8C%85%E5%90%AB%E5%8D%95%E4%B8%8B%E5%88%92%E7%BA%BF%E5%89%8D%E7%BC%80%E5%92%8C%E7%BB%93%E5%B0%BE%E5%92%8C%E5%8F%8C%E4%B8%8B%E5%88%92%E7%BA%BF%E5%89%8D%E7%BC%80%E7%BB%93%E5%B0%BE%E5%8C%BA%E5%88%AB%E6%98%AF%E4%BB%80%E4%B9%88">22.Python 中会有函数或成员变量包含单下划线前缀和结尾，和双下划线前缀结尾，区别是什么?</a></li>
<li><a href="python_interview.md#23json-%E5%BA%8F%E5%88%97%E5%8C%96%E6%97%B6%E5%8F%AF%E4%BB%A5%E5%A4%84%E7%90%86%E7%9A%84%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E6%9C%89%E5%93%AA%E4%BA%9B%E5%A6%82%E4%BD%95%E5%AE%9A%E5%88%B6%E6%94%AF%E6%8C%81-datetime-%E7%B1%BB%E5%9E%8B">23.json 序列化时，可以处理的数据类型有哪些？如何定制支持 datetime 类型？</a></li>
<li><a href="python_interview.md#24json-%E5%BA%8F%E5%88%97%E5%8C%96%E6%97%B6%E9%BB%98%E8%AE%A4%E9%81%87%E5%88%B0%E4%B8%AD%E6%96%87%E4%BC%9A%E8%BD%AC%E6%8D%A2%E6%88%90-unicode%E5%A6%82%E6%9E%9C%E6%83%B3%E8%A6%81%E4%BF%9D%E7%95%99%E4%B8%AD%E6%96%87%E6%80%8E%E4%B9%88%E5%8A%9E">24.json 序列化时，默认遇到中文会转换成 unicode，如果想要保留中文怎么办？</a></li>
<li><a href="python_interview.md#25%E5%A6%82%E6%9E%9C%E5%BD%93%E5%89%8D%E7%9A%84%E6%97%A5%E6%9C%9F%E4%B8%BA-20190530%E8%A6%81%E6%B1%82%E5%86%99%E4%B8%80%E4%B8%AA%E5%87%BD%E6%95%B0%E8%BE%93%E5%87%BA-n-%E5%A4%A9%E5%90%8E%E7%9A%84%E6%97%A5%E6%9C%9F%E6%AF%94%E5%A6%82-n-%E4%B8%BA-2%E5%88%99%E8%BE%93%E5%87%BA-20190601">25.如果当前的日期为 20190530，要求写一个函数输出 N 天后的日期，(比如 N 为 2，则输出 20190601)</a></li>
<li><a href="python_interview.md#26python-%E5%AD%97%E5%85%B8%E5%92%8C-json-%E5%AD%97%E7%AC%A6%E4%B8%B2%E7%9B%B8%E4%BA%92%E8%BD%AC%E5%8C%96%E6%96%B9%E6%B3%95">26.python 字典和 json 字符串相互转化方法</a></li>
<li><a href="python_interview.md#27%E5%87%BD%E6%95%B0%E8%A3%85%E9%A5%B0%E5%99%A8%E6%9C%89%E4%BB%80%E4%B9%88%E4%BD%9C%E7%94%A8%E8%AF%B7%E5%88%97%E4%B8%BE%E8%AF%B4%E6%98%8E">27.函数装饰器有什么作用？请列举说明？</a></li>
<li><a href="python_interview.md#28__call__">28.<strong>call</strong></a></li>
<li><a href="python_interview.md#29%E5%A6%82%E4%BD%95%E5%88%A4%E6%96%AD%E4%B8%80%E4%B8%AA%E5%AF%B9%E8%B1%A1%E6%98%AF%E5%87%BD%E6%95%B0%E8%BF%98%E6%98%AF%E6%96%B9%E6%B3%95">29.如何判断一个对象是函数还是方法？</a></li>
<li><a href="python_interview.md#30python%E5%AE%9E%E7%8E%B0%E6%8E%A5%E5%8F%A3-">30.python实现接口 ？</a></li>
<li><a href="python_interview.md#31python-%E4%B8%AD%E7%9A%84%E5%8F%8D%E5%B0%84%E4%BA%86%E8%A7%A3%E4%B9%88">31.Python 中的反射了解么?</a></li>
<li><a href="python_interview.md#32metaclass-or-type">32.metaclass or type</a></li>
<li><a href="python_interview.md#33python%E4%B8%AD%E9%80%92%E5%BD%92%E7%9A%84%E6%9C%80%E5%A4%A7%E6%AC%A1%E6%95%B01000-%E6%80%8E%E4%B9%88%E6%94%B9">33.Python中递归的最大次数1000 ?怎么改</a></li>
<li><a href="python_interview.md#34%E5%88%97%E4%B8%BE-5-%E4%B8%AA-python-%E4%B8%AD%E7%9A%84%E5%BC%82%E5%B8%B8%E7%B1%BB%E5%9E%8B%E4%BB%A5%E5%8F%8A%E5%85%B6%E5%90%AB%E4%B9%89">34.列举 5 个 Python 中的异常类型以及其含义</a></li>
<li><a href="python_interview.md#35wawb-%E6%96%87%E4%BB%B6%E5%86%99%E5%85%A5%E6%A8%A1%E5%BC%8F%E7%9A%84%E5%8C%BA%E5%88%AB">35.w、a+、wb 文件写入模式的区别</a></li>
<li><a href="python_interview.md#36%E4%B8%BE%E4%BE%8B-sort-%E5%92%8C-sorted-%E7%9A%84%E5%8C%BA%E5%88%AB">36.举例 sort 和 sorted 的区别</a></li>
<li><a href="python_interview.md#37%E5%9C%A8-requests-%E6%A8%A1%E5%9D%97%E4%B8%ADrequestscontent-%E5%92%8C-requeststext-%E4%BB%80%E4%B9%88%E5%8C%BA%E5%88%AB">37.在 requests 模块中，requests.content 和 requests.text 什么区别</a></li>
<li><a href="python_interview.md#38python%E6%96%B0%E5%BC%8F%E7%B1%BB%E5%92%8C%E7%BB%8F%E5%85%B8%E7%B1%BB%E7%9A%84%E5%8C%BA%E5%88%AB">38.python新式类和经典类的区别</a></li>
<li><a href="python_interview.md#39%E5%AD%97%E7%AC%A6%E4%B8%B2%E7%9A%84%E6%93%8D%E4%BD%9C%E9%A2%98%E7%9B%AE">39.字符串的操作题目</a></li>
<li><a href="python_interview.md#40%E5%8F%AF%E5%8F%98%E7%B1%BB%E5%9E%8B%E5%92%8C%E4%B8%8D%E5%8F%AF%E5%8F%98%E7%B1%BB%E5%9E%8B">40.可变类型和不可变类型</a></li>
<li><a href="python_interview.md#41is%E5%92%8C%E6%9C%89%E4%BB%80%E4%B9%88%E5%8C%BA%E5%88%AB">41.is和==有什么区别？</a></li>
<li><a href="python_interview.md#42%E6%B1%82%E5%87%BA%E5%88%97%E8%A1%A8%E6%89%80%E6%9C%89%E5%A5%87%E6%95%B0%E5%B9%B6%E6%9E%84%E9%80%A0%E6%96%B0%E5%88%97%E8%A1%A8">42.求出列表所有奇数并构造新列表</a></li>
<li><a href="python_interview.md#43%E7%94%A8%E4%B8%80%E8%A1%8Cpython%E4%BB%A3%E7%A0%81%E5%86%99%E5%87%BA12310248">43.用一行python代码写出1+2+3+10248</a></li>
<li><a href="python_interview.md#44python%E4%B8%AD%E5%8F%98%E9%87%8F%E7%9A%84%E4%BD%9C%E7%94%A8%E5%9F%9F%E5%8F%98%E9%87%8F%E6%9F%A5%E6%89%BE%E9%A1%BA%E5%BA%8F">44.Python中变量的作用域？（变量查找顺序)</a></li>
<li>[45.字符串 <code>&quot;123&quot;</code> 转换成 <code>123</code>，不使用内置api，例如 <code>int()</code>](#45字符串-<code>&quot;123&quot;</code>-转换成-<code>123</code>不使用内置api例如-<code>int</code>)</li>
<li><a href="python_interview.md#46given-an-array-of-integers">46.Given an array of integers</a></li>
<li><a href="python_interview.md#47%E6%9C%89%E4%B8%80%E4%B8%AAjsonline%E6%A0%BC%E5%BC%8F%E7%9A%84%E6%96%87%E4%BB%B6filetxt%E5%A4%A7%E5%B0%8F%E7%BA%A6%E4%B8%BA10k">47.有一个jsonline格式的文件file.txt大小约为10K</a></li>
<li><a href="python_interview.md#48%E8%BF%94%E5%9B%9E%E8%AF%A5%E6%96%87%E4%BB%B6%E5%A4%B9%E4%B8%AD%E6%89%80%E6%9C%89%E6%96%87%E4%BB%B6%E7%9A%84%E8%B7%AF%E5%BE%84">48.返回该文件夹中所有文件的路径</a></li>
<li><a href="python_interview.md#49%E8%AE%BE%E8%AE%A1%E5%AE%9E%E7%8E%B0%E9%81%8D%E5%8E%86%E7%9B%AE%E5%BD%95%E4%B8%8E%E5%AD%90%E7%9B%AE%E5%BD%95%E6%8A%93%E5%8F%96pyc%E6%96%87%E4%BB%B6">49.设计实现遍历目录与子目录，抓取.pyc文件</a></li>
<li><a href="python_interview.md#50%E8%BE%93%E5%85%A5%E6%97%A5%E6%9C%9F-%E5%88%A4%E6%96%AD%E8%BF%99%E4%B8%80%E5%A4%A9%E6%98%AF%E8%BF%99%E4%B8%80%E5%B9%B4%E7%9A%84%E7%AC%AC%E5%87%A0%E5%A4%A9">50.输入日期， 判断这一天是这一年的第几天？</a></li>
<li><a href="python_interview.md#51%E6%89%93%E4%B9%B1%E4%B8%80%E4%B8%AA%E6%8E%92%E5%A5%BD%E5%BA%8F%E7%9A%84list%E5%AF%B9%E8%B1%A1alist">51.打乱一个排好序的list对象alist？</a></li>
<li><a href="python_interview.md#52%E7%8E%B0%E6%9C%89%E5%AD%97%E5%85%B8-d-a24g52i12k33%E8%AF%B7%E6%8C%89value%E5%80%BC%E8%BF%9B%E8%A1%8C%E6%8E%92%E5%BA%8F">52.现有字典 d= {‘a’:24,’g’:52,’i’:12,’k’:33}请按value值进行排序?</a></li>
<li><a href="python_interview.md#53%E5%AD%97%E5%85%B8%E6%8E%A8%E5%AF%BC%E5%BC%8F">53.字典推导式</a></li>
<li>[54.请反转字符串 “aStr”?](#54请反转字符串-“astr”)</li>
<li><a href="python_interview.md#55%E8%AF%B7%E6%8C%89alist%E4%B8%AD%E5%85%83%E7%B4%A0%E7%9A%84age%E7%94%B1%E5%A4%A7%E5%88%B0%E5%B0%8F%E6%8E%92%E5%BA%8F">55.请按alist中元素的age由大到小排序</a></li>
<li><a href="python_interview.md#56%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E7%9A%84%E8%BE%93%E5%87%BA%E7%BB%93%E6%9E%9C%E5%B0%86%E6%98%AF%E4%BB%80%E4%B9%88">56.下面代码的输出结果将是什么？</a></li>
<li><a href="python_interview.md#57%E5%86%99%E4%B8%80%E4%B8%AA%E5%88%97%E8%A1%A8%E7%94%9F%E6%88%90%E5%BC%8F%E4%BA%A7%E7%94%9F%E4%B8%80%E4%B8%AA%E5%85%AC%E5%B7%AE%E4%B8%BA11%E7%9A%84%E7%AD%89%E5%B7%AE%E6%95%B0%E5%88%97">57.写一个列表生成式，产生一个公差为11的等差数列</a></li>
<li><a href="python_interview.md#58%E7%BB%99%E5%AE%9A%E4%B8%A4%E4%B8%AA%E5%88%97%E8%A1%A8%E6%80%8E%E4%B9%88%E6%89%BE%E5%87%BA%E4%BB%96%E4%BB%AC%E7%9B%B8%E5%90%8C%E7%9A%84%E5%85%83%E7%B4%A0%E5%92%8C%E4%B8%8D%E5%90%8C%E7%9A%84%E5%85%83%E7%B4%A0">58.给定两个列表，怎么找出他们相同的元素和不同的元素？</a></li>
<li><a href="python_interview.md#59%E7%BB%9F%E8%AE%A1%E4%B8%80%E4%B8%AA%E6%96%87%E6%9C%AC%E4%B8%AD%E5%8D%95%E8%AF%8D%E9%A2%91%E6%AC%A1%E6%9C%80%E9%AB%98%E7%9A%8410%E4%B8%AA%E5%8D%95%E8%AF%8D">59.统计一个文本中单词频次最高的10个单词？</a></li>
<li><a href="python_interview.md#60%E7%BB%99%E5%AE%9A%E4%B8%80%E4%B8%AA%E4%BB%BB%E6%84%8F%E9%95%BF%E5%BA%A6%E6%95%B0%E7%BB%84%E5%AE%9E%E7%8E%B0%E4%B8%80%E4%B8%AA%E5%87%BD%E6%95%B0">60.给定一个任意长度数组，实现一个函数</a></li>
<li><a href="python_interview.md#61%E5%86%99%E4%B8%80%E4%B8%AA%E5%87%BD%E6%95%B0%E6%89%BE%E5%87%BA%E4%B8%80%E4%B8%AA%E6%95%B4%E6%95%B0%E6%95%B0%E7%BB%84%E4%B8%AD%E7%AC%AC%E4%BA%8C%E5%A4%A7%E7%9A%84%E6%95%B0">61.写一个函数找出一个整数数组中，第二大的数</a></li>
<li><a href="python_interview.md#62%E9%98%85%E8%AF%BB%E4%B8%80%E4%B8%8B%E4%BB%A3%E7%A0%81%E4%BB%96%E4%BB%AC%E7%9A%84%E8%BE%93%E5%87%BA%E7%BB%93%E6%9E%9C%E6%98%AF%E4%BB%80%E4%B9%88">62.阅读一下代码他们的输出结果是什么？</a></li>
<li><a href="python_interview.md#63%E7%BB%9F%E8%AE%A1%E4%B8%80%E6%AE%B5%E5%AD%97%E7%AC%A6%E4%B8%B2%E4%B8%AD%E5%AD%97%E7%AC%A6%E5%87%BA%E7%8E%B0%E7%9A%84%E6%AC%A1%E6%95%B0">63.统计一段字符串中字符出现的次数</a></li>
<li><a href="python_interview.md#64super%E5%87%BD%E6%95%B0%E7%9A%84%E5%85%B7%E4%BD%93%E7%94%A8%E6%B3%95%E5%92%8C%E5%9C%BA%E6%99%AF">64.super函数的具体用法和场景</a></li>
</ul>
</li>
</ul>
</li>
<li><p><a href="python_interview.md#python%E9%AB%98%E7%BA%A7">Python高级</a></p>
<ul>
<li><a href="python_interview.md#%E5%85%83%E7%B1%BB">元类</a><ul>
<li><a href="python_interview.md#65python%E4%B8%AD%E7%B1%BB%E6%96%B9%E6%B3%95%E7%B1%BB%E5%AE%9E%E4%BE%8B%E6%96%B9%E6%B3%95%E9%9D%99%E6%80%81%E6%96%B9%E6%B3%95%E6%9C%89%E4%BD%95%E5%8C%BA%E5%88%AB">65.Python中类方法、类实例方法、静态方法有何区别？</a></li>
<li><a href="python_interview.md#66%E9%81%8D%E5%8E%86%E4%B8%80%E4%B8%AAobject%E7%9A%84%E6%89%80%E6%9C%89%E5%B1%9E%E6%80%A7%E5%B9%B6print%E6%AF%8F%E4%B8%80%E4%B8%AA%E5%B1%9E%E6%80%A7%E5%90%8D">66.遍历一个object的所有属性，并print每一个属性名？</a></li>
<li><a href="python_interview.md#67%E5%86%99%E4%B8%80%E4%B8%AA%E7%B1%BB%E5%B9%B6%E8%AE%A9%E5%AE%83%E5%B0%BD%E5%8F%AF%E8%83%BD%E5%A4%9A%E7%9A%84%E6%94%AF%E6%8C%81%E6%93%8D%E4%BD%9C%E7%AC%A6">67.写一个类，并让它尽可能多的支持操作符?</a></li>
<li><a href="python_interview.md#68%E4%BB%8B%E7%BB%8Dcythonpypy-cpython-numba%E5%90%84%E6%9C%89%E4%BB%80%E4%B9%88%E7%BC%BA%E7%82%B9">68.介绍Cython，Pypy Cpython Numba各有什么缺点</a></li>
<li><a href="python_interview.md#69%E8%AF%B7%E6%8F%8F%E8%BF%B0%E6%8A%BD%E8%B1%A1%E7%B1%BB%E5%92%8C%E6%8E%A5%E5%8F%A3%E7%B1%BB%E7%9A%84%E5%8C%BA%E5%88%AB%E5%92%8C%E8%81%94%E7%B3%BB">69.请描述抽象类和接口类的区别和联系</a></li>
<li><a href="python_interview.md#70python%E4%B8%AD%E5%A6%82%E4%BD%95%E5%8A%A8%E6%80%81%E8%8E%B7%E5%8F%96%E5%92%8C%E8%AE%BE%E7%BD%AE%E5%AF%B9%E8%B1%A1%E7%9A%84%E5%B1%9E%E6%80%A7">70.Python中如何动态获取和设置对象的属性？</a></li>
</ul>
</li>
<li><a href="python_interview.md#%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86%E4%B8%8E%E5%9E%83%E5%9C%BE%E5%9B%9E%E6%94%B6%E6%9C%BA%E5%88%B6">内存管理与垃圾回收机制</a><ul>
<li><a href="python_interview.md#71%E5%93%AA%E4%BA%9B%E6%93%8D%E4%BD%9C%E4%BC%9A%E5%AF%BC%E8%87%B4python%E5%86%85%E5%AD%98%E6%B3%84%E9%9C%B2%E6%80%8E%E4%B9%88%E5%A4%84%E7%90%86">71.哪些操作会导致Python内存泄露，怎么处理？</a></li>
<li><a href="python_interview.md#72%E5%85%B3%E4%BA%8E%E5%86%85%E5%AD%98%E6%BA%A2%E5%87%BA%E5%92%8C%E5%86%85%E5%AD%98%E6%B3%84%E6%BC%8F%E7%9A%84%E5%8C%BA%E5%88%AB">72.关于内存溢出和内存泄漏的区别</a></li>
<li><a href="python_interview.md#73python%E7%9A%84%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86%E6%9C%BA%E5%88%B6%E5%8F%8A%E8%B0%83%E4%BC%98%E6%89%8B%E6%AE%B5">73.Python的内存管理机制及调优手段？</a></li>
</ul>
</li>
<li><a href="python_interview.md#%E5%87%BD%E6%95%B0">函数</a><ul>
<li><a href="python_interview.md#74%E4%BB%80%E4%B9%88%E6%98%AFhash%E6%95%A3%E5%88%97%E5%87%BD%E6%95%B0">74.什么是Hash（散列函数）？</a></li>
<li><a href="python_interview.md#75%E7%BC%96%E5%86%99%E5%87%BD%E6%95%B0%E7%9A%844%E4%B8%AA%E5%8E%9F%E5%88%99">75.编写函数的4个原则</a></li>
<li><a href="python_interview.md#76%E5%87%BD%E6%95%B0%E8%B0%83%E7%94%A8%E5%8F%82%E6%95%B0%E7%9A%84%E4%BC%A0%E9%80%92%E6%96%B9%E5%BC%8F%E6%98%AF%E5%80%BC%E4%BC%A0%E9%80%92%E8%BF%98%E6%98%AF%E5%BC%95%E7%94%A8%E4%BC%A0%E9%80%92">76.函数调用参数的传递方式是值传递还是引用传递？</a></li>
<li><a href="python_interview.md#77%E5%A6%82%E4%BD%95%E5%9C%A8function%E9%87%8C%E9%9D%A2%E8%AE%BE%E7%BD%AE%E4%B8%80%E4%B8%AA%E5%85%A8%E5%B1%80%E5%8F%98%E9%87%8F">77.如何在function里面设置一个全局变量</a></li>
<li><a href="python_interview.md#78%E5%B8%A6%E5%8F%82%E6%95%B0%E7%9A%84%E8%A3%85%E9%A5%B0%E5%99%A8">78.带参数的装饰器?</a></li>
<li><a href="python_interview.md#79%E9%80%92%E5%BD%92%E5%87%BD%E6%95%B0%E5%81%9C%E6%AD%A2%E7%9A%84%E6%9D%A1%E4%BB%B6">79.递归函数停止的条件？</a></li>
</ul>
</li>
<li><a href="python_interview.md#%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F">设计模式</a><ul>
<li><a href="python_interview.md#80%E5%AF%B9%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E7%9A%84%E7%90%86%E8%A7%A3%E7%AE%80%E8%BF%B0%E4%BD%A0%E4%BA%86%E8%A7%A3%E7%9A%84%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F">80.对设计模式的理解，简述你了解的设计模式？</a></li>
<li><a href="python_interview.md#81python%E5%A6%82%E4%BD%95%E5%AE%9E%E7%8E%B0%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F">81.python如何实现单例模式</a></li>
<li><a href="python_interview.md#82%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F%E7%9A%84%E5%BA%94%E7%94%A8%E5%9C%BA%E6%99%AF%E6%9C%89%E9%82%A3%E4%BA%9B">82.单例模式的应用场景有那些？</a></li>
<li><a href="python_interview.md#83%E5%AF%B9%E8%A3%85%E9%A5%B0%E5%99%A8%E7%9A%84%E7%90%86%E8%A7%A3%E5%B9%B6%E5%86%99%E5%87%BA%E4%B8%80%E4%B8%AA%E8%AE%A1%E6%97%B6%E5%99%A8%E8%AE%B0%E5%BD%95%E6%96%B9%E6%B3%95%E6%89%A7%E8%A1%8C%E6%80%A7%E8%83%BD%E7%9A%84%E8%A3%85%E9%A5%B0%E5%99%A8">83.对装饰器的理解，并写出一个计时器记录方法执行性能的装饰器？</a></li>
<li><a href="python_interview.md#84%E8%A7%A3%E9%87%8A%E4%BB%A5%E4%B8%8B%E4%BB%80%E4%B9%88%E6%98%AF%E9%97%AD%E5%8C%85">84.解释以下什么是闭包？</a></li>
<li><a href="python_interview.md#85%E5%87%BD%E6%95%B0%E8%A3%85%E9%A5%B0%E5%99%A8%E6%9C%89%E4%BB%80%E4%B9%88%E4%BD%9C%E7%94%A8">85.函数装饰器有什么作用？</a></li>
<li><a href="python_interview.md#86%E7%94%9F%E6%88%90%E5%99%A8%E8%BF%AD%E4%BB%A3%E5%99%A8%E7%9A%84%E5%8C%BA%E5%88%AB">86.生成器，迭代器的区别？</a></li>
<li><a href="python_interview.md#87x%E6%98%AF%E4%BB%80%E4%B9%88%E7%B1%BB%E5%9E%8B">87.X是什么类型?</a></li>
<li><a href="python_interview.md#88%E8%AF%B7%E7%94%A8%E4%B8%80%E8%A1%8C%E4%BB%A3%E7%A0%81-%E5%AE%9E%E7%8E%B0%E5%B0%861-n-%E7%9A%84%E6%95%B4%E6%95%B0%E5%88%97%E8%A1%A8%E4%BB%A53%E4%B8%BA%E5%8D%95%E4%BD%8D%E5%88%86%E7%BB%84">88.请用一行代码 实现将1-N 的整数列表以3为单位分组</a></li>
<li><a href="python_interview.md#89python%E4%B8%ADyield%E7%9A%84%E7%94%A8%E6%B3%95">89.Python中yield的用法?</a></li>
</ul>
</li>
<li><a href="python_interview.md#%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1">面向对象</a><ul>
<li><a href="python_interview.md#90python%E7%9A%84%E9%AD%94%E6%B3%95%E6%96%B9%E6%B3%95">90.Python的魔法方法</a></li>
<li><a href="python_interview.md#91%E8%B0%88%E8%B0%88%E4%BD%A0%E5%AF%B9%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E7%9A%84%E7%90%86%E8%A7%A3">91.谈谈你对面向对象的理解？</a></li>
</ul>
</li>
<li><a href="python_interview.md#%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F">正则表达式</a><ul>
<li><a href="python_interview.md#92%E8%AF%B7%E5%86%99%E5%87%BA%E4%B8%80%E6%AE%B5%E4%BB%A3%E7%A0%81%E7%94%A8%E6%AD%A3%E5%88%99%E5%8C%B9%E9%85%8D%E5%87%BAip">92.请写出一段代码用正则匹配出ip？</a></li>
<li><a href="python_interview.md#93a--%E2%80%9Cabbbccc%E2%80%9D%E7%94%A8%E6%AD%A3%E5%88%99%E5%8C%B9%E9%85%8D%E4%B8%BAabccc%E4%B8%8D%E7%AE%A1%E6%9C%89%E5%A4%9A%E5%B0%91b%E5%B0%B1%E5%87%BA%E7%8E%B0%E4%B8%80%E6%AC%A1">93.a = “abbbccc”，用正则匹配为abccc,不管有多少b，就出现一次？</a></li>
<li><a href="python_interview.md#94python%E5%AD%97%E7%AC%A6%E4%B8%B2%E6%9F%A5%E6%89%BE%E5%92%8C%E6%9B%BF%E6%8D%A2">94.Python字符串查找和替换？</a></li>
<li><a href="python_interview.md#95%E7%94%A8python%E5%8C%B9%E9%85%8Dhtml-g-tag%E7%9A%84%E6%97%B6%E5%80%99%3C%3E-%E5%92%8C-%3C%3E-%E6%9C%89%E4%BB%80%E4%B9%88%E5%8C%BA%E5%88%AB">95.用Python匹配HTML g tag的时候，&lt;.&gt; 和 &lt;.*?&gt; 有什么区别</a></li>
<li><a href="python_interview.md#96%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F%E8%B4%AA%E5%A9%AA%E4%B8%8E%E9%9D%9E%E8%B4%AA%E5%A9%AA%E6%A8%A1%E5%BC%8F%E7%9A%84%E5%8C%BA%E5%88%AB">96.正则表达式贪婪与非贪婪模式的区别？</a></li>
</ul>
</li>
<li><a href="python_interview.md#%E7%B3%BB%E7%BB%9F%E7%BC%96%E7%A8%8B">系统编程</a><ul>
<li><a href="python_interview.md#97%E8%BF%9B%E7%A8%8B%E6%80%BB%E7%BB%93">97.进程总结</a></li>
<li><a href="python_interview.md#98%E8%B0%88%E8%B0%88%E4%BD%A0%E5%AF%B9%E5%A4%9A%E8%BF%9B%E7%A8%8B%E5%A4%9A%E7%BA%BF%E7%A8%8B%E4%BB%A5%E5%8F%8A%E5%8D%8F%E7%A8%8B%E7%9A%84%E7%90%86%E8%A7%A3%E9%A1%B9%E7%9B%AE%E6%98%AF%E5%90%A6%E7%94%A8">98.谈谈你对多进程，多线程，以及协程的理解，项目是否用？</a></li>
<li><a href="python_interview.md#99python%E5%BC%82%E6%AD%A5%E4%BD%BF%E7%94%A8%E5%9C%BA%E6%99%AF%E6%9C%89%E9%82%A3%E4%BA%9B">99.Python异步使用场景有那些？</a></li>
<li><a href="python_interview.md#100%E5%A4%9A%E7%BA%BF%E7%A8%8B%E5%85%B1%E5%90%8C%E6%93%8D%E4%BD%9C%E5%90%8C%E4%B8%80%E4%B8%AA%E6%95%B0%E6%8D%AE%E4%BA%92%E6%96%A5%E9%94%81%E5%90%8C%E6%AD%A5">100.多线程共同操作同一个数据互斥锁同步？</a></li>
<li><a href="python_interview.md#101%E4%BB%80%E4%B9%88%E6%98%AF%E5%A4%9A%E7%BA%BF%E7%A8%8B%E7%AB%9E%E4%BA%89">101.什么是多线程竞争？</a></li>
<li><a href="python_interview.md#102%E8%AF%B7%E4%BB%8B%E7%BB%8D%E4%B8%80%E4%B8%8Bpython%E7%9A%84%E7%BA%BF%E7%A8%8B%E5%90%8C%E6%AD%A5">102.请介绍一下Python的线程同步？</a></li>
<li><a href="python_interview.md#103%E8%A7%A3%E9%87%8A%E4%BB%A5%E4%B8%8B%E4%BB%80%E4%B9%88%E6%98%AF%E9%94%81%E6%9C%89%E5%93%AA%E5%87%A0%E7%A7%8D%E9%94%81">103.解释以下什么是锁，有哪几种锁？</a></li>
<li><a href="python_interview.md#104%E4%BB%80%E4%B9%88%E6%98%AF%E6%AD%BB%E9%94%81">104.什么是死锁？</a></li>
<li><a href="python_interview.md#105%E5%A4%9A%E7%BA%BF%E7%A8%8B%E4%BA%A4%E4%BA%92%E8%AE%BF%E9%97%AE%E6%95%B0%E6%8D%AE%E5%A6%82%E6%9E%9C%E8%AE%BF%E9%97%AE%E5%88%B0%E4%BA%86%E5%B0%B1%E4%B8%8D%E8%AE%BF%E9%97%AE%E4%BA%86">105.多线程交互访问数据，如果访问到了就不访问了？</a></li>
<li><a href="python_interview.md#106%E4%BB%80%E4%B9%88%E6%98%AF%E7%BA%BF%E7%A8%8B%E5%AE%89%E5%85%A8%E4%BB%80%E4%B9%88%E6%98%AF%E4%BA%92%E6%96%A5%E9%94%81">106.什么是线程安全，什么是互斥锁？</a></li>
<li><a href="python_interview.md#107%E8%AF%B4%E8%AF%B4%E4%B8%8B%E9%9D%A2%E5%87%A0%E4%B8%AA%E6%A6%82%E5%BF%B5%EF%BC%9A%E5%90%8C%E6%AD%A5%E5%BC%82%E6%AD%A5%E9%98%BB%E5%A1%9E%E9%9D%9E%E9%98%BB%E5%A1%9E">107.说说下面几个概念：同步，异步，阻塞，非阻塞？</a></li>
<li><a href="python_interview.md#108%E4%BB%80%E4%B9%88%E6%98%AF%E5%83%B5%E5%B0%B8%E8%BF%9B%E7%A8%8B%E5%92%8C%E5%AD%A4%E5%84%BF%E8%BF%9B%E7%A8%8B%E6%80%8E%E4%B9%88%E9%81%BF%E5%85%8D%E5%83%B5%E5%B0%B8%E8%BF%9B%E7%A8%8B">108.什么是僵尸进程和孤儿进程？怎么避免僵尸进程？</a></li>
<li><a href="python_interview.md#109python%E4%B8%AD%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B%E7%9A%84%E4%BD%BF%E7%94%A8%E5%9C%BA%E6%99%AF">109.python中进程与线程的使用场景？</a></li>
<li><a href="python_interview.md#110%E7%BA%BF%E7%A8%8B%E6%98%AF%E5%B9%B6%E5%8F%91%E8%BF%98%E6%98%AF%E5%B9%B6%E8%A1%8C%E8%BF%9B%E7%A8%8B%E6%98%AF%E5%B9%B6%E5%8F%91%E8%BF%98%E6%98%AF%E5%B9%B6%E8%A1%8C">110.线程是并发还是并行，进程是并发还是并行？</a></li>
<li><a href="python_interview.md#111%E5%B9%B6%E8%A1%8Cparallel%E5%92%8C%E5%B9%B6%E5%8F%91concurrency">111.并行(parallel)和并发（concurrency)?</a></li>
<li><a href="python_interview.md#112io%E5%AF%86%E9%9B%86%E5%9E%8B%E5%92%8Ccpu%E5%AF%86%E9%9B%86%E5%9E%8B%E5%8C%BA%E5%88%AB">112.IO密集型和CPU密集型区别？</a></li>
<li><a href="python_interview.md#113python-asyncio%E7%9A%84%E5%8E%9F%E7%90%86">113.python asyncio的原理？</a></li>
</ul>
</li>
<li><a href="python_interview.md#%E7%BD%91%E7%BB%9C%E7%BC%96%E7%A8%8B">网络编程</a><ul>
<li><a href="python_interview.md#114%E6%80%8E%E4%B9%88%E5%AE%9E%E7%8E%B0%E5%BC%BA%E8%A1%8C%E5%85%B3%E9%97%AD%E5%AE%A2%E6%88%B7%E7%AB%AF%E5%92%8C%E6%9C%8D%E5%8A%A1%E5%99%A8%E4%B9%8B%E9%97%B4%E7%9A%84%E8%BF%9E%E6%8E%A5">114.怎么实现强行关闭客户端和服务器之间的连接?</a></li>
<li><a href="python_interview.md#115%E7%AE%80%E8%BF%B0tcp%E5%92%8Cudp%E7%9A%84%E5%8C%BA%E5%88%AB%E4%BB%A5%E5%8F%8A%E4%BC%98%E7%BC%BA%E7%82%B9">115.简述TCP和UDP的区别以及优缺点?</a></li>
<li><a href="python_interview.md#116%E7%AE%80%E8%BF%B0%E6%B5%8F%E8%A7%88%E5%99%A8%E9%80%9A%E8%BF%87wsgi%E8%AF%B7%E6%B1%82%E5%8A%A8%E6%80%81%E8%B5%84%E6%BA%90%E7%9A%84%E8%BF%87%E7%A8%8B">116.简述浏览器通过WSGI请求动态资源的过程?</a></li>
<li><a href="python_interview.md#117%E6%8F%8F%E8%BF%B0%E7%94%A8%E6%B5%8F%E8%A7%88%E5%99%A8%E8%AE%BF%E9%97%AEwwwbaiducom%E7%9A%84%E8%BF%87%E7%A8%8B">117.描述用浏览器访问www.baidu.com的过程</a></li>
<li><a href="python_interview.md#118post%E5%92%8Cget%E8%AF%B7%E6%B1%82%E7%9A%84%E5%8C%BA%E5%88%AB">118.Post和Get请求的区别?</a></li>
<li><a href="python_interview.md#119%E5%88%97%E5%87%BA%E4%BD%A0%E7%9F%A5%E9%81%93%E7%9A%84http%E5%8D%8F%E8%AE%AE%E7%9A%84%E7%8A%B6%E6%80%81%E7%A0%81%E8%AF%B4%E5%87%BA%E8%A1%A8%E7%A4%BA%E4%BB%80%E4%B9%88%E6%84%8F%E6%80%9D">119.列出你知道的HTTP协议的状态码，说出表示什么意思？</a></li>
<li><a href="python_interview.md#120%E8%AF%B7%E7%AE%80%E5%8D%95%E8%AF%B4%E4%B8%80%E4%B8%8B%E4%B8%89%E6%AC%A1%E6%8F%A1%E6%89%8B%E5%92%8C%E5%9B%9B%E6%AC%A1%E6%8C%A5%E6%89%8B">120.请简单说一下三次握手和四次挥手？</a></li>
<li><a href="python_interview.md#121%E4%B8%BA%E4%BB%80%E4%B9%88%E5%AE%A2%E6%88%B7%E7%AB%AF%E5%9C%A8time-wait%E7%8A%B6%E6%80%81%E5%BF%85%E9%A1%BB%E7%AD%89%E5%BE%852msl%E7%9A%84%E6%97%B6%E9%97%B4">121.为什么客户端在TIME-WAIT状态必须等待2MSL的时间？</a></li>
<li><a href="python_interview.md#122%E8%AF%B4%E8%AF%B4http%E5%92%8Chttps%E5%8C%BA%E5%88%AB">122.说说HTTP和HTTPS区别？</a></li>
<li><a href="python_interview.md#123%E8%B0%88%E4%B8%80%E4%B8%8Bhttp%E5%8D%8F%E8%AE%AE%E4%BB%A5%E5%8F%8A%E5%8D%8F%E8%AE%AE%E5%A4%B4%E9%83%A8%E4%B8%AD%E8%A1%A8%E7%A4%BA%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E7%9A%84%E5%AD%97%E6%AE%B5">123.谈一下HTTP协议以及协议头部中表示数据类型的字段？</a></li>
<li><a href="python_interview.md#124http%E8%AF%B7%E6%B1%82%E6%96%B9%E6%B3%95%E9%83%BD%E6%9C%89%E4%BB%80%E4%B9%88">124.HTTP请求方法都有什么？</a></li>
<li><a href="python_interview.md#125%E4%BD%BF%E7%94%A8socket%E5%A5%97%E6%8E%A5%E5%AD%97%E9%9C%80%E8%A6%81%E4%BC%A0%E5%85%A5%E5%93%AA%E4%BA%9B%E5%8F%82%E6%95%B0-">125.使用Socket套接字需要传入哪些参数 ？</a></li>
<li><a href="python_interview.md#126http%E5%B8%B8%E8%A7%81%E8%AF%B7%E6%B1%82%E5%A4%B4">126.HTTP常见请求头？</a></li>
<li><a href="python_interview.md#127%E4%B8%83%E5%B1%82%E6%A8%A1%E5%9E%8B">127.七层模型？</a></li>
<li><a href="python_interview.md#128url%E7%9A%84%E5%BD%A2%E5%BC%8F">128.url的形式？</a></li>
</ul>
</li>
</ul>
</li>
<li><p><a href="python_interview.md#web">Web</a></p>
<ul>
<li><p><a href="python_interview.md#flask">Flask</a></p>
<ul>
<li><a href="python_interview.md#129%E5%AF%B9flask%E8%93%9D%E5%9B%BEblueprint%E7%9A%84%E7%90%86%E8%A7%A3">129.对Flask蓝图(Blueprint)的理解？</a></li>
<li><a href="python_interview.md#130flask-%E5%92%8C-django-%E8%B7%AF%E7%94%B1%E6%98%A0%E5%B0%84%E7%9A%84%E5%8C%BA%E5%88%AB">130.Flask 和 Django 路由映射的区别？</a></li>
</ul>
</li>
<li><p><a href="python_interview.md#django">Django</a></p>
<ul>
<li><p><a href="python_interview.md#131orm%E6%98%AF%E4%BB%80%E4%B9%88orm%E7%9A%84%E4%BC%98%E7%BC%BA%E7%82%B9">131.ORM是什么，ORM的优缺点</a></p>
</li>
<li><p><a href="python_interview.md#132%E6%9F%A5%E6%89%BE-django-%E9%A1%B9%E7%9B%AE%E4%B8%AD%E7%9A%84%E6%80%A7%E8%83%BD%E7%93%B6%E9%A2%88">132.查找 Django 项目中的性能瓶颈</a></p>
</li>
<li><p><a href="python_interview.md#133%E4%BB%80%E4%B9%88%E6%98%AFwsgiuwsgiuwsgi">133.什么是wsgi,uwsgi,uWSGI?</a></p>
</li>
<li><p><a href="python_interview.md#134djangoflasktornado%E7%9A%84%E5%AF%B9%E6%AF%94">134.Django、Flask、Tornado的对比？</a></p>
</li>
<li><p><a href="python_interview.md#135cors-%E5%92%8C-csrf%E7%9A%84%E5%8C%BA%E5%88%AB">135.CORS 和 CSRF的区别？</a></p>
</li>
<li><p><a href="python_interview.md#136sessioncookiejwt%E7%9A%84%E7%90%86%E8%A7%A3">136.Session,Cookie,JWT的理解</a></p>
</li>
<li><p><a href="python_interview.md#137%E7%AE%80%E8%BF%B0django%E8%AF%B7%E6%B1%82%E7%94%9F%E5%91%BD%E5%91%A8%E6%9C%9F">137.简述Django请求生命周期</a></p>
</li>
<li><p><a href="python_interview.md#138%E7%94%A8%E7%9A%84restframework%E5%AE%8C%E6%88%90api%E5%8F%91%E9%80%81%E6%97%B6%E9%97%B4%E6%97%B6%E5%8C%BA">138.用的restframework完成api发送时间时区</a></p>
</li>
<li><p><a href="python_interview.md#139nginxtomcatapach%E5%88%B0%E9%83%BD%E6%98%AF%E4%BB%80%E4%B9%88">139.nginx,tomcat,apach到都是什么？</a></p>
</li>
<li><p><a href="python_interview.md#140%E8%AF%B7%E7%BB%99%E5%87%BA%E4%BD%A0%E7%86%9F%E6%82%89%E5%85%B3%E7%B3%BB%E6%95%B0%E6%8D%AE%E5%BA%93%E8%8C%83%E5%BC%8F%E6%9C%89%E5%93%AA%E4%BA%9B%E6%9C%89%E4%BB%80%E4%B9%88%E4%BD%9C%E7%94%A8">140.请给出你熟悉关系数据库范式有哪些，有什么作用？</a></p>
</li>
<li><p><a href="python_interview.md#141%E7%AE%80%E8%BF%B0qq%E7%99%BB%E9%99%86%E8%BF%87%E7%A8%8B">141.简述QQ登陆过程</a></p>
</li>
<li><p><a href="python_interview.md#142%E9%A1%B9%E7%9B%AE%E4%B8%AD%E6%97%A5%E5%BF%97%E7%9A%84%E4%BD%9C%E7%94%A8">142.项目中日志的作用</a></p>
</li>
<li><p><a href="python_interview.md#143django%E4%B8%AD%E9%97%B4%E4%BB%B6%E7%9A%84%E4%BD%BF%E7%94%A8">143.django中间件的使用？</a></p>
</li>
<li><p><a href="python_interview.md#144%E8%B0%88%E4%B8%80%E4%B8%8B%E4%BD%A0%E5%AF%B9uwsgi%E5%92%8Cnginx%E7%9A%84%E7%90%86%E8%A7%A3">144.谈一下你对uWSGI和nginx的理解？</a></p>
</li>
<li><p><a href="python_interview.md#145python%E4%B8%AD%E4%B8%89%E5%A4%A7%E6%A1%86%E6%9E%B6%E5%90%84%E8%87%AA%E7%9A%84%E5%BA%94%E7%94%A8%E5%9C%BA%E6%99%AF">145.Python中三大框架各自的应用场景？</a></p>
</li>
<li><p><a href="python_interview.md#146django%E4%B8%AD%E5%93%AA%E9%87%8C%E7%94%A8%E5%88%B0%E4%BA%86%E7%BA%BF%E7%A8%8B%E5%93%AA%E9%87%8C%E7%94%A8%E5%88%B0%E4%BA%86%E5%8D%8F%E7%A8%8B%E5%93%AA%E9%87%8C%E7%94%A8%E5%88%B0%E4%BA%86%E8%BF%9B%E7%A8%8B">146.Django中哪里用到了线程？哪里用到了协程？哪里用到了进程？</a></p>
</li>
<li><p><a href="python_interview.md#147%E6%9C%89%E7%94%A8%E8%BF%87django-rest-framework%E5%90%97">147.有用过Django REST framework吗？</a></p>
</li>
<li><p><a href="python_interview.md#148%E5%AF%B9cookies%E4%B8%8Esession%E7%9A%84%E4%BA%86%E8%A7%A3%E4%BB%96%E4%BB%AC%E8%83%BD%E5%8D%95%E7%8B%AC%E7%94%A8%E5%90%97">148.对cookies与session的了解？他们能单独用吗？</a></p>
</li>
<li><p><a href="python_interview.md#149%E6%B5%8B%E8%AF%95%E5%B7%A5%E5%85%B7">149.测试工具</a></p>
<p><strong>Python基础</strong></p>
<p><strong>Python语言基本</strong></p>
<p><strong>1.列出 5 个常用 Python 标准库?</strong></p>
<p>os, logging, system, time, re, math,threading</p>
<p><strong>2.Python的内建数据类型有哪些?</strong></p>
<p>string, int, list, tuple, dict</p>
<p><strong>3.简述 with 方法打开处理文件帮我我们做了什么？</strong></p>
<p>with 语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源，比如文件使用后自动关闭、线程中锁的自动获取和释放等。</p>
</li>
</ul>
</li>
</ul>
</li>
</ul>
<p>with语句即“上下文管理器”，在程序中用来表示代码执行过程中所处的前后环境 上下文管理器：含有<strong>enter</strong>和<strong>exit</strong>方法的对象就是上下文管理器。</p>
<p><strong>enter</strong>()：在执行语句之前，首先执行该方法，通常返回一个实例对象，如果with语句有as目标，则将对象赋值给as目标。</p>
<p><strong>exit</strong>()：执行语句结束后，自动调用<strong>exit</strong>()方法，用户释放资源，若此方法返回布尔值True，程序会忽略异常。 使用环境：文件读写、线程锁的自动释放等。</p>
<h4 id="4-Python的可变和不可变数据类型？"><a href="#4-Python的可变和不可变数据类型？" class="headerlink" title="4.Python的可变和不可变数据类型？"></a>4.Python的可变和不可变数据类型？</h4><p>可变 list， dict， set 不可变 int string tuple</p>
<h4 id="5-Python-获取当前日期？"><a href="#5-Python-获取当前日期？" class="headerlink" title="5.Python 获取当前日期？"></a>5.Python 获取当前日期？</h4><p>from datetime import datetime; datetime.now()</p>
<h4 id="6-谈谈对-Python-的了解和其他语言的区别"><a href="#6-谈谈对-Python-的了解和其他语言的区别" class="headerlink" title="6.谈谈对 Python 的了解和其他语言的区别"></a>6.谈谈对 Python 的了解和其他语言的区别</h4><p>python是典型的动态类型强类型语言</p>
<p>强类型语言, 不需要隐士转换</p>
<p>解释性， 解释型语言使用解释器将源码逐行解释成机器码并立即执行，不会进行整体性的编译和链接处理，相当于把编译语言中的编译和解释混合到一起同时完成。</p>
<p>简洁优雅 ，面向对象，跨平台，</p>
<p>Python是动态类型语言，而Java是静态类型语言.</p>
<h4 id="7-说说你知道的Python3-和-Python2-之间的区别"><a href="#7-说说你知道的Python3-和-Python2-之间的区别" class="headerlink" title="7.说说你知道的Python3 和 Python2 之间的区别"></a>7.说说你知道的Python3 和 Python2 之间的区别</h4><p>print, string/unicode, exception, divide, xrange,</p>
<h4 id="8-了解-Python-之禅么？"><a href="#8-了解-Python-之禅么？" class="headerlink" title="8.了解 Python 之禅么？"></a>8.了解 Python 之禅么？</h4><figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br></pre></td><td class="code"><pre><span class="line">import this</span><br><span class="line"></span><br><span class="line">The Zen of Python, by Tim Peters</span><br><span class="line">Beautiful is better than ugly.</span><br><span class="line">Explicit is better than implicit.</span><br><span class="line">Simple is better than complex.</span><br><span class="line">Complex is better than complicated.</span><br><span class="line">Flat is better than nested.</span><br><span class="line">Sparse is better than dense.</span><br><span class="line">Readability counts.</span><br><span class="line">Special cases aren&#x27;t special enough to break the rules.</span><br><span class="line">Although practicality beats purity.</span><br><span class="line">Errors should never pass silently.</span><br><span class="line">Unless explicitly silenced.</span><br><span class="line">In the face of ambiguity, refuse the temptation to guess.</span><br><span class="line">There should be one-- and preferably only one --obvious way to do it.</span><br><span class="line">Although that way may not be obvious at first unless you&#x27;re Dutch.</span><br><span class="line">Now is better than never.</span><br><span class="line">Although never is often better than *right* now.</span><br><span class="line">If the implementation is hard to explain, it&#x27;s a bad idea.</span><br><span class="line">If the implementation is easy to explain, it may be a good idea.</span><br><span class="line">Namespaces are one honking great idea -- let&#x27;s do more of those!</span><br><span class="line"></span><br><span class="line">优美胜于丑陋（Python 以编写优美的代码为目标）</span><br><span class="line">明了胜于晦涩（优美的代码应当是明了的，命名规范，风格相似）</span><br><span class="line">简洁胜于复杂（优美的代码应当是简洁的，不要有复杂的内部实现）</span><br><span class="line">复杂胜于凌乱（如果复杂不可避免，那代码间也不能有难懂的关系，要保持接口简洁）</span><br><span class="line">扁平胜于嵌套（优美的代码应当是扁平的，不能有太多的嵌套）</span><br><span class="line">间隔胜于紧凑（优美的代码有适当的间隔，不要奢望一行代码解决问题）</span><br><span class="line">可读性很重要（优美的代码是可读的）</span><br><span class="line">即便假借特例的实用性之名，也不可违背这些规则（这些规则至高无上）</span><br><span class="line">不要包容所有错误，除非你确定需要这样做（精准地捕获异常，不写 except:pass 风格的代码）</span><br><span class="line">当存在多种可能，不要尝试去猜测</span><br><span class="line">而是尽量找一种，最好是唯一一种明显的解决方案（如果不确定，就用穷举法）</span><br><span class="line">虽然这并不容易，因为你不是 Python 之父（这里的 Dutch 是指 Guido ）</span><br><span class="line">做也许好过不做，但不假思索就动手还不如不做（动手之前要细思量）</span><br><span class="line">如果你无法向人描述你的方案，那肯定不是一个好方案；反之亦然（方案测评标准）</span><br><span class="line">命名空间是一种绝妙的理念，我们应当多加利用（倡导与号召）</span><br></pre></td></tr></table></figure>

<h4 id="9-了解-docstring-么？"><a href="#9-了解-docstring-么？" class="headerlink" title="9.了解 docstring 么？"></a>9.了解 docstring 么？</h4><p>文档字符串是一个重要工具，用于解释文档程序 ，帮助你的程序文档更加简单易懂。 我们可以在函数体的第一行使用一对三个单引号 或者一对三个双引号 来定义文档字符串。 你可以使用 <strong>doc</strong> 调用函数中的文档字符串属性</p>
<h4 id="10-了解类型注解么？"><a href="#10-了解类型注解么？" class="headerlink" title="10.了解类型注解么？"></a>10.了解类型注解么？</h4><figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">def list_to_str (param_list:list,connect_str: str = &quot; &quot;) - &gt; str:</span><br><span class="line">    paas</span><br></pre></td></tr></table></figure>

<p>python3 中注解用来给参数， 返回值，变量的类型加上注解，对代码没影响 Python提供了一个工具方便我们测试类型注解的正确性</p>
<p>pip install mypy ; mypy demo.py 若无错误则无输出</p>
<h4 id="11-例举你知道-Python-对象的命名规范，例如方法或者类等"><a href="#11-例举你知道-Python-对象的命名规范，例如方法或者类等" class="headerlink" title="11.例举你知道 Python 对象的命名规范，例如方法或者类等"></a>11.例举你知道 Python 对象的命名规范，例如方法或者类等</h4><p>变量命名：字母数字下划线，不能以数字开头</p>
<p>_ 受保护的</p>
<p>__ 私有的</p>
<p><strong>init</strong> 内置变量</p>
<p>函数和方法（类中叫做方法，模块中称作函数）命名 ：</p>
<h4 id="12-例举几个规范-Python-代码风格的工具"><a href="#12-例举几个规范-Python-代码风格的工具" class="headerlink" title="12.例举几个规范 Python 代码风格的工具"></a>12.例举几个规范 Python 代码风格的工具</h4><p>pylint，yapf, autopep8, flake8</p>
<h4 id="13-一个编码为-GBK-的字符串-S，要将其转成-UTF-8-编码的字符串，应如何操作？"><a href="#13-一个编码为-GBK-的字符串-S，要将其转成-UTF-8-编码的字符串，应如何操作？" class="headerlink" title="13.一个编码为 GBK 的字符串 S，要将其转成 UTF-8 编码的字符串，应如何操作？"></a>13.一个编码为 GBK 的字符串 S，要将其转成 UTF-8 编码的字符串，应如何操作？</h4><figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">demo_str = &quot;demo&quot;.encode(&quot;gbk&quot;)</span><br><span class="line">demo=demo_str.decode(&#x27;gbk&#x27;).encode(&#x27;utf-8&#x27;）</span><br></pre></td></tr></table></figure>

<h4 id="14-用正则切分字符串去除非符号"><a href="#14-用正则切分字符串去除非符号" class="headerlink" title="14.用正则切分字符串去除非符号"></a>14.用正则切分字符串去除非符号</h4><figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">import re</span><br><span class="line">s=&quot;info：xiaoZhang 33 shandong&quot;</span><br><span class="line">re.compile(r&#x27;\W&#x27;).split(s)</span><br><span class="line"></span><br><span class="line">output:</span><br><span class="line">[&#x27;info&#x27;, &#x27;xiaoZhang&#x27;, &#x27;33&#x27;, &#x27;shandong&#x27;]</span><br></pre></td></tr></table></figure>

<h4 id="15-单引号、双引号、三引号的区别？"><a href="#15-单引号、双引号、三引号的区别？" class="headerlink" title="15.单引号、双引号、三引号的区别？"></a>15.单引号、双引号、三引号的区别？</h4><p>在不需要转义的时候， 单引号和双引号无区别</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">&quot;abc &#x27;wewe&#x27;we&quot;</span><br><span class="line">&#x27;abc &quot;wewe&quot;we&#x27;</span><br><span class="line">&#x27;abc \&#x27;wewe\&#x27;we&#x27;</span><br></pre></td></tr></table></figure>

<h4 id="16-1-2-3-4-5-6-一行代码展开该列表，得出-1-2-3-4-5-6"><a href="#16-1-2-3-4-5-6-一行代码展开该列表，得出-1-2-3-4-5-6" class="headerlink" title="16.[[1,2],[3,4],[5,6]]一行代码展开该列表，得出[1,2,3,4,5,6]"></a>16.[[1,2],[3,4],[5,6]]一行代码展开该列表，得出[1,2,3,4,5,6]</h4><figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">question_list =  [[1,2],[3,4],[5,6]]</span><br><span class="line">[a for inside in question_list for a in inside]</span><br></pre></td></tr></table></figure>

<h4 id="17-哪些不能作为字典的健"><a href="#17-哪些不能作为字典的健" class="headerlink" title="17.哪些不能作为字典的健"></a>17.哪些不能作为字典的健</h4><p>字典中的键是不可变类型，可变类型list和dict不能作为字典键</p>
<p>一个对象能不能作为字典的key，就取决于其有没有<strong>hash</strong>方法</p>
<h4 id="18-如何交换字典-“A”：1-”B”：2-的键和值？"><a href="#18-如何交换字典-“A”：1-”B”：2-的键和值？" class="headerlink" title="18.如何交换字典 {“A”：1,”B”：2}的键和值？"></a>18.如何交换字典 {“A”：1,”B”：2}的键和值？</h4><figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">result_dic = &#123;v: k for k, v in demo_dic.items()&#125;</span><br></pre></td></tr></table></figure>

<h4 id="19-对生成器类型的对象实现切片功能"><a href="#19-对生成器类型的对象实现切片功能" class="headerlink" title="19.对生成器类型的对象实现切片功能"></a>19.对生成器类型的对象实现切片功能</h4><figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">import itertools</span><br><span class="line">itertools.islice(gener, 10, 20)</span><br></pre></td></tr></table></figure>

<h4 id="20-关于list-tuple-copy-和-deepcopy-的区别是什么？"><a href="#20-关于list-tuple-copy-和-deepcopy-的区别是什么？" class="headerlink" title="20.关于list tuple copy 和 deepcopy 的区别是什么？"></a>20.关于list tuple copy 和 deepcopy 的区别是什么？</h4><p>tuple：</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">a = (1, 2, 3, [4, 5, 6, 7], 8)</span><br><span class="line">a[3] = 3  //typeerror</span><br><span class="line">a[3][3] = 9 // a (1, 2, 3, [4, 5, 6, 9], 8)</span><br></pre></td></tr></table></figure>

<p>列表是可变数据类型，数据的值可以修改的</p>
<p>这里只是修改了元祖子对象的值，而不是修改了元祖的值</p>
<p>修改可变类型的值不会改变内存id，因此元祖的引用还是没有发生变化</p>
<p>可以这么理解，只要不修改元祖中值的<strong>内存id</strong>，那么就可以进行“修改元祖”操作扩展，</p>
<p>面试官可能会问到：元祖是否可以被修改？</p>
<p>答：元祖是不可变数据类型，因此不能修改元祖中的值，但是如果元组中有可变数据类型，那么可以修改可变数据类型中的值，修改可变数据类型的值并不会使其内存id发生变化，所以元祖中元素中的内存id也没有改变，因此就做到了“修改元祖”操作</p>
<p>list:</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line">a = [1,2,[3,4]]</span><br><span class="line">b = a</span><br><span class="line">c = a[:]</span><br><span class="line">d = a.copy()</span><br><span class="line">e = copy.deepcopy(a)</span><br><span class="line"></span><br><span class="line">id(a), id(b), id(c), id(d), id(e)  // 只有a b 是同一个指向</span><br><span class="line"> &gt;&gt;&gt; (4398429512, 4398429512, 4398398664, 4398429576, 4398429192)</span><br><span class="line"></span><br><span class="line">a.append(5) // 只有b跟着改变</span><br><span class="line">a, b, c,d,e</span><br><span class="line">([1, 2, [3, 4], 5], [1, 2, [3, 4], 5], [1, 2, [3, 4]], [1, 2, [3, 4]], [1, 2, [3, 4]])</span><br><span class="line"></span><br><span class="line">a[2][1] = 7 // 除了deepcopy， 其他都跟着变了</span><br><span class="line">a, b, c,d,e</span><br><span class="line">([1, 2, [3, 7], 5], [1, 2, [3, 7], 5], [1, 2, [3, 7]], [1, 2, [3, 7]], [1, 2, [3, 4]])</span><br></pre></td></tr></table></figure>

<p>copy 仅拷贝对象本身，而不拷贝对象中引用的其它对象。</p>
<p>deepcopy 除拷贝对象本身，而且拷贝对象中引用的其它对象。（子对象）</p>
<h4 id="21-代码中经常遇到的-args-kwargs-含义及用法。"><a href="#21-代码中经常遇到的-args-kwargs-含义及用法。" class="headerlink" title="21.代码中经常遇到的_args, *_kwargs 含义及用法。"></a>21.代码中经常遇到的_args, *_kwargs 含义及用法。</h4><p>args 是 arguments 的缩写，表示位置参数</p>
<p>kwargs 是 keyword arguments 的缩写，表示关键字参数</p>
<h4 id="22-Python-中会有函数或成员变量包含单下划线前缀和结尾，和双下划线前缀结尾，区别是什么"><a href="#22-Python-中会有函数或成员变量包含单下划线前缀和结尾，和双下划线前缀结尾，区别是什么" class="headerlink" title="22.Python 中会有函数或成员变量包含单下划线前缀和结尾，和双下划线前缀结尾，区别是什么?"></a>22.Python 中会有函数或成员变量包含单下划线前缀和结尾，和双下划线前缀结尾，区别是什么?</h4><p>下划线开头的命名方式被常用于模块中，在一个模块中以单下划线开头的变量和方法会被默认划入模块内部范围。</p>
<p>当使用 from my_module import * 导入时，单下划线开头的变量和方法是不会被导入的。但使用 import my_module 导入的话，仍然可以用 my_module._var 这样的形式访问属性或方法。</p>
<p>双下划线开头和结尾的是一些 python 的“魔术”对象</p>
<p>class A中定义的属性<strong>cont ，这样的变量获取时需要用A._A</strong>cont</p>
<h4 id="23-json-序列化时，可以处理的数据类型有哪些？如何定制支持-datetime-类型？"><a href="#23-json-序列化时，可以处理的数据类型有哪些？如何定制支持-datetime-类型？" class="headerlink" title="23.json 序列化时，可以处理的数据类型有哪些？如何定制支持 datetime 类型？"></a>23.json 序列化时，可以处理的数据类型有哪些？如何定制支持 datetime 类型？</h4><p>json序列化时，可以处理列表、字典、字符、数值、布尔和None 定制datetime类型↓</p>
<h4 id="24-json-序列化时，默认遇到中文会转换成-unicode，如果想要保留中文怎么办？"><a href="#24-json-序列化时，默认遇到中文会转换成-unicode，如果想要保留中文怎么办？" class="headerlink" title="24.json 序列化时，默认遇到中文会转换成 unicode，如果想要保留中文怎么办？"></a>24.json 序列化时，默认遇到中文会转换成 unicode，如果想要保留中文怎么办？</h4><p>print(json.dumps(dict_demo, ensure_ascii=False))</p>
<h4 id="25-如果当前的日期为-20190530，要求写一个函数输出-N-天后的日期，-比如-N-为-2，则输出-20190601"><a href="#25-如果当前的日期为-20190530，要求写一个函数输出-N-天后的日期，-比如-N-为-2，则输出-20190601" class="headerlink" title="25.如果当前的日期为 20190530，要求写一个函数输出 N 天后的日期，(比如 N 为 2，则输出 20190601)"></a>25.如果当前的日期为 20190530，要求写一个函数输出 N 天后的日期，(比如 N 为 2，则输出 20190601)</h4><figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">from datetime import datetime, timedelta</span><br><span class="line">now_date = &quot;20190530&quot;</span><br><span class="line">now_date = datetime.strptime(now_date, &quot;%Y%m%d&quot;).date()</span><br><span class="line">offset = timedelta(days=2)</span><br><span class="line">(now_date + offset).strftime(&quot;%Y%m%d&quot;)</span><br></pre></td></tr></table></figure>

<h4 id="26-python-字典和-json-字符串相互转化方法"><a href="#26-python-字典和-json-字符串相互转化方法" class="headerlink" title="26.python 字典和 json 字符串相互转化方法"></a>26.python 字典和 json 字符串相互转化方法</h4><figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line">#导包</span><br><span class="line">import json</span><br><span class="line"></span><br><span class="line">#json字符串转换成字典</span><br><span class="line">json.loads(json_str)</span><br><span class="line"></span><br><span class="line">#字典转换成json字符串</span><br><span class="line">json.dumps(dict)</span><br></pre></td></tr></table></figure>

<h4 id="27-函数装饰器有什么作用？请列举说明？"><a href="#27-函数装饰器有什么作用？请列举说明？" class="headerlink" title="27.函数装饰器有什么作用？请列举说明？"></a>27.函数装饰器有什么作用？请列举说明？</h4><p>1，引入日志 2，函数执行时间统计3，执行函数前预备处理4，执行函数后清理功能5，权限校验等场景6，缓存7，事务处理</p>
<h4 id="28-call"><a href="#28-call" class="headerlink" title="28.call"></a>28.<strong>call</strong></h4><p>可以调用的对象: 一个特殊的魔术方法可以让类的实例的行为表现的像函数一样</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line">class Entity:</span><br><span class="line">&#x27;&#x27;&#x27;调用实体来改变实体的位置。&#x27;&#x27;&#x27;</span><br><span class="line"></span><br><span class="line">    def __init__(self, size, x, y):</span><br><span class="line">        self.x, self.y = x, y</span><br><span class="line">        self.size = size</span><br><span class="line"></span><br><span class="line">    def __call__(self, x, y):</span><br><span class="line">        &#x27;&#x27;&#x27;改变实体的位置&#x27;&#x27;&#x27;</span><br><span class="line">        self.x, self.y = x, y</span><br><span class="line"></span><br><span class="line">e = Entity(1, 2, 3) // 创建实例</span><br><span class="line">e(4, 5) //实例可以象函数那样执行，并传入x y值，修改对象的x y</span><br></pre></td></tr></table></figure>

<p><a target="_blank" rel="noopener" href="https://www.jianshu.com/p/e1d95c4e1697?utm_source=oschina-app">https://www.jianshu.com/p/e1d95c4e1697?utm_source=oschina-app</a></p>
<h4 id="29-如何判断一个对象是函数还是方法？"><a href="#29-如何判断一个对象是函数还是方法？" class="headerlink" title="29.如何判断一个对象是函数还是方法？"></a>29.如何判断一个对象是函数还是方法？</h4><p>在类外声明def为函数</p>
<p>类中声明def：使用类调用为函数，使用实例化对象调用为方法</p>
<p>可以使用isinstance()判断</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br></pre></td><td class="code"><pre><span class="line">class Work(object):</span><br><span class="line">    def show(self):</span><br><span class="line">        print(&quot;执行show方法&quot;)</span><br><span class="line"></span><br><span class="line">work = Work()</span><br><span class="line">print(Work.show)</span><br><span class="line">print(work.show)</span><br><span class="line"></span><br><span class="line">结果：</span><br><span class="line">&lt;function Work.show at 0x000001CC55BC5268&gt;</span><br><span class="line">&lt;bound method Work.show of &lt;__main__.Work object at 0x000001CC55C2F240&gt;&gt;</span><br><span class="line"></span><br><span class="line">from types import MethodType,FunctionType</span><br><span class="line">print(isinstance(Work.show,FunctionType))</span><br><span class="line">print(isinstance(work.show,MethodType))</span><br><span class="line"></span><br><span class="line">结果：</span><br><span class="line">True</span><br><span class="line">True</span><br></pre></td></tr></table></figure>

<h4 id="30-python实现接口-？"><a href="#30-python实现接口-？" class="headerlink" title="30.python实现接口 ？"></a>30.python实现接口 ？</h4><p>接口只是定义了一些方法，而没有去实现，多用于程序设计时，只是设计需要有什么样的功能，但是并没有实现任何功能，这些功能需要被另一个类（B）继承后，由 类B去实现其中的某个功能或全部功能。</p>
<p>遵循：开放封闭原则，依赖导致原则，接口隔离原则，继承多态。</p>
<p>编程思想：为子类做规范； 归一化设计：几个类都实现了相同的方法</p>
<p>抽象类：最好单继承，且可以简单的实现功能，接口类：可以多继承，且最好不实现具体功能</p>
<p>在python中接口由抽象类和抽象方法去实现，接口是不能被实例化的，只能被别的类继承去实现相应的功能。</p>
<p>个人觉得接口在python中并没有那么重要，因为如果要继承接口，需要把其中的每个方法全部实现，否则会报编译错误，还不如直接定义一个class，其中的方法实现全部为pass，让子类重写这些函数。</p>
<p>方法一：用抽象类和抽象函数实现方法（适用于单继承）</p>
<p>方法二：用普通类定义接口（推荐）</p>
<h4 id="31-Python-中的反射了解么"><a href="#31-Python-中的反射了解么" class="headerlink" title="31.Python 中的反射了解么?"></a>31.Python 中的反射了解么?</h4><p>在Python中，能够通过一个对象，找出其type、class、attribute或method的能力，称为反射或自省</p>
<p>具有反射能力的函数有type(),isinstance(),callable().dir().getattr()等</p>
<h4 id="32-metaclass-or-type"><a href="#32-metaclass-or-type" class="headerlink" title="32.metaclass or type"></a>32.metaclass or type</h4><p><a target="_blank" rel="noopener" href="https://www.liaoxuefeng.com/wiki/897692888725344/923030550637312">https://www.liaoxuefeng.com/wiki/897692888725344/923030550637312</a></p>
<h4 id="33-Python中递归的最大次数1000-怎么改"><a href="#33-Python中递归的最大次数1000-怎么改" class="headerlink" title="33.Python中递归的最大次数1000 ?怎么改"></a>33.Python中递归的最大次数1000 ?怎么改</h4><figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">import sys</span><br><span class="line">sys.setrecursionlimit(1500) # set the maximum depth as 1500</span><br></pre></td></tr></table></figure>

<h4 id="34-列举-5-个-Python-中的异常类型以及其含义"><a href="#34-列举-5-个-Python-中的异常类型以及其含义" class="headerlink" title="34.列举 5 个 Python 中的异常类型以及其含义"></a>34.列举 5 个 Python 中的异常类型以及其含义</h4><figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br></pre></td><td class="code"><pre><span class="line">BaseException</span><br><span class="line"> +-- SystemExit</span><br><span class="line"> +-- KeyboardInterrupt</span><br><span class="line"> +-- GeneratorExit</span><br><span class="line"> +-- Exception</span><br><span class="line">      +-- StopIteration</span><br><span class="line">      +-- StopAsyncIteration</span><br><span class="line">      +-- ArithmeticError</span><br><span class="line">      |    +-- FloatingPointError</span><br><span class="line">      |    +-- OverflowError</span><br><span class="line">      |    +-- ZeroDivisionError</span><br><span class="line">      +-- AssertionError</span><br><span class="line">      +-- AttributeError</span><br><span class="line">      +-- BufferError</span><br><span class="line">      +-- EOFError</span><br><span class="line">      +-- ImportError</span><br><span class="line">      |    +-- ModuleNotFoundError</span><br><span class="line">      +-- LookupError</span><br><span class="line">      |    +-- IndexError</span><br><span class="line">      |    +-- KeyError</span><br><span class="line">      +-- MemoryError</span><br><span class="line">      +-- NameError</span><br><span class="line">      |    +-- UnboundLocalError</span><br><span class="line">      +-- OSError</span><br><span class="line">      |    +-- BlockingIOError</span><br><span class="line">      |    +-- ChildProcessError</span><br><span class="line">      |    +-- ConnectionError</span><br><span class="line">      |    |    +-- BrokenPipeError</span><br><span class="line">      |    |    +-- ConnectionAbortedError</span><br><span class="line">      |    |    +-- ConnectionRefusedError</span><br><span class="line">      |    |    +-- ConnectionResetError</span><br><span class="line">      |    +-- FileExistsError</span><br><span class="line">      |    +-- FileNotFoundError</span><br><span class="line">      |    +-- InterruptedError</span><br><span class="line">      |    +-- IsADirectoryError</span><br><span class="line">      |    +-- NotADirectoryError</span><br><span class="line">      |    +-- PermissionError</span><br><span class="line">      |    +-- ProcessLookupError</span><br><span class="line">      |    +-- TimeoutError</span><br><span class="line">      +-- ReferenceError</span><br><span class="line">      +-- RuntimeError</span><br><span class="line">      |    +-- NotImplementedError</span><br><span class="line">      |    +-- RecursionError</span><br><span class="line">      +-- SyntaxError</span><br><span class="line">      |    +-- IndentationError</span><br><span class="line">      |         +-- TabError</span><br><span class="line">      +-- SystemError</span><br><span class="line">      +-- TypeError</span><br><span class="line">      +-- ValueError</span><br><span class="line">      |    +-- UnicodeError</span><br><span class="line">      |         +-- UnicodeDecodeError</span><br><span class="line">      |         +-- UnicodeEncodeError</span><br><span class="line">      |         +-- UnicodeTranslateError</span><br><span class="line">      +-- Warning</span><br><span class="line">           +-- DeprecationWarning</span><br><span class="line">           +-- PendingDeprecationWarning</span><br><span class="line">           +-- RuntimeWarning</span><br><span class="line">           +-- SyntaxWarning</span><br><span class="line">           +-- UserWarning</span><br><span class="line">           +-- FutureWarning</span><br><span class="line">           +-- ImportWarning</span><br><span class="line">           +-- UnicodeWarning</span><br><span class="line">           +-- BytesWarning</span><br><span class="line">           +-- ResourceWarning</span><br></pre></td></tr></table></figure>

<h4 id="35-w、a-、wb-文件写入模式的区别"><a href="#35-w、a-、wb-文件写入模式的区别" class="headerlink" title="35.w、a+、wb 文件写入模式的区别"></a>35.w、a+、wb 文件写入模式的区别</h4><p>r : 读取文件，若文件不存在则会报错<br> w: 写入文件，若文件不存在则会先创建再写入，会覆盖原文件<br> a : 写入文件，若文件不存在则会先创建再写入，但不会覆盖原文件，而是追加在文件末尾<br> rb,wb：分别于r,w类似，用于读写二进制文件<br> r+ : 可读、可写，文件不存在也会报错，写操作时会覆盖<br> w+ : 可读，可写，文件不存在先创建，会覆盖<br> a+ ：可读、可写，文件不存在先创建，不会覆盖，追加在末尾</p>
<h4 id="36-举例-sort-和-sorted-的区别"><a href="#36-举例-sort-和-sorted-的区别" class="headerlink" title="36.举例 sort 和 sorted 的区别"></a>36.举例 sort 和 sorted 的区别</h4><p>使用sort()方法对list排序会修改list本身,不会返回新list，sort()不能对dict字典进行排序；</p>
<p>sorted方法对可迭代的序列排序生成新的序列，对dict排序默认会按照dict的key值进行排序，最后返回的结果是一个对key值排序好的list；</p>
<p>sorted对tuple， dict依然有效，而sort不行</p>
<h4 id="37-在-requests-模块中，requests-content-和-requests-text-什么区别"><a href="#37-在-requests-模块中，requests-content-和-requests-text-什么区别" class="headerlink" title="37.在 requests 模块中，requests.content 和 requests.text 什么区别"></a>37.在 requests 模块中，requests.content 和 requests.text 什么区别</h4><p>.content中间存的是字节码 .text存的是.content编码后的字符串</p>
<p>操作方式就是，如果想取得文本就用.text，如果想获取图片，就用.content</p>
<h4 id="38-python新式类和经典类的区别"><a href="#38-python新式类和经典类的区别" class="headerlink" title="38.python新式类和经典类的区别"></a>38.python新式类和经典类的区别</h4><p>这2篇文章很好的介绍了新式类的特性:</p>
<p>新式类多继承搜索顺序(广度优先)：先在水平方向查找，然后再向上查找</p>
<p>经典类多继承搜索顺序(深度优先)：先深入继承树左侧查找，然后再返回，开始查找右侧</p>
<p><a target="_blank" rel="noopener" href="http://stackoverflow.com/questions/54867/what-is-the-difference-between-old-style-and-new-style-classes-in-python">http://stackoverflow.com/questions/54867/what-is-the-difference-between-old-style-and-new-style-classes-in-python</a> <a target="_blank" rel="noopener" href="http://www.cnblogs.com/btchenguang/archive/2012/09/17/2689146.html">http://www.cnblogs.com/btchenguang/archive/2012/09/17/2689146.html</a></p>
<h4 id="39-字符串的操作题目"><a href="#39-字符串的操作题目" class="headerlink" title="39.字符串的操作题目"></a>39.字符串的操作题目</h4><p>全字母短句 PANGRAM 是包含所有英文字母的句子，比如：A QUICK BROWN FOX JUMPS OVER THE LAZY DOG. 定义并实现一个方法 get_missing_letter, 传入一个字符串采纳数，返回参数字符串变成一个 PANGRAM 中所缺失的字符。应该忽略传入字符串参数中的大小写，返回应该都是小写字符并按字母顺序排序（请忽略所有非 ACSII 字符）</p>
<p><strong>下面示例是用来解释，双引号不需要考虑:</strong></p>
<p>(0)输入: “A quick brown for jumps over the lazy dog”</p>
<p>返回： “”</p>
<p>(1)输入: “A slow yellow fox crawls under the proactive dog”</p>
<p>返回: “bjkmqz”</p>
<p>(2)输入: “Lions, and tigers, and bears, oh my!”</p>
<p>返回: “cfjkpquvwxz”</p>
<p>(3)输入: “”</p>
<p>返回：”abcdefghijklmnopqrstuvwxyz”</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">get_missing_letter</span>(<span class="params">a</span>):</span></span><br><span class="line">    s1 = <span class="built_in">set</span>(<span class="string">&quot;abcdefghijklmnopqrstuvwxyz&quot;</span>)</span><br><span class="line">    s2 = <span class="built_in">set</span>(a.lower())</span><br><span class="line">    ret = <span class="string">&quot;&quot;</span>.join(<span class="built_in">sorted</span>(s1-s2))</span><br><span class="line">    <span class="keyword">return</span> ret</span><br><span class="line"></span><br><span class="line">print(get_missing_letter(<span class="string">&quot;python&quot;</span>))</span><br></pre></td></tr></table></figure>

<h4 id="40-可变类型和不可变类型"><a href="#40-可变类型和不可变类型" class="headerlink" title="40.可变类型和不可变类型"></a>40.可变类型和不可变类型</h4><p>1,可变类型有list,dict.不可变类型有string，number,tuple.</p>
<p>2,当进行修改操作时，可变类型传递的是内存中的地址，也就是说，直接修改内存中的值，并没有开辟新的内存。</p>
<p>3,不可变类型被改变时，并没有改变原内存地址中的值，而是开辟一块新的内存，将原地址中的值复制过去，对这块新开辟的内存中的值进行操作。</p>
<h4 id="41-is和-有什么区别？"><a href="#41-is和-有什么区别？" class="headerlink" title="41.is和==有什么区别？"></a>41.is和==有什么区别？</h4><p>a = 1024 b = 1024 a is b &gt;False a == b &gt; True is：比较的是两个对象的id值是否相等，也就是比较俩对象是否为同一个实例对象。是否指向同一个内存地址</p>
<p>== ： 比较的两个对象的内容/值是否相等，默认会调用对象的eq()方法</p>
<h4 id="42-求出列表所有奇数并构造新列表"><a href="#42-求出列表所有奇数并构造新列表" class="headerlink" title="42.求出列表所有奇数并构造新列表"></a>42.求出列表所有奇数并构造新列表</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">a = [<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>,<span class="number">4</span>,<span class="number">5</span>,<span class="number">6</span>,<span class="number">7</span>,<span class="number">8</span>,<span class="number">9</span>,<span class="number">10</span>]</span><br><span class="line">res = [ i <span class="keyword">for</span> i <span class="keyword">in</span> a <span class="keyword">if</span> i%<span class="number">2</span>==<span class="number">1</span>]</span><br><span class="line">print(res)</span><br></pre></td></tr></table></figure>

<h4 id="43-用一行python代码写出1-2-3-10248"><a href="#43-用一行python代码写出1-2-3-10248" class="headerlink" title="43.用一行python代码写出1+2+3+10248"></a>43.用一行python代码写出1+2+3+10248</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">from</span> functools <span class="keyword">import</span> reduce</span><br><span class="line"><span class="comment">#1.使用sum内置求和函数</span></span><br><span class="line">num = <span class="built_in">sum</span>([<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>,<span class="number">10248</span>])</span><br><span class="line">print(num)</span><br><span class="line"><span class="comment">#2.reduce 函数</span></span><br><span class="line">num1 = reduce(<span class="keyword">lambda</span> x,y :x+y,[<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>,<span class="number">10248</span>])</span><br><span class="line">print(num1)</span><br></pre></td></tr></table></figure>

<h4 id="44-Python中变量的作用域？（变量查找顺序"><a href="#44-Python中变量的作用域？（变量查找顺序" class="headerlink" title="44.Python中变量的作用域？（变量查找顺序)"></a>44.Python中变量的作用域？（变量查找顺序)</h4><p>函数作用域的LEGB顺序</p>
<p>1.什么是LEGB?</p>
<p>L： local 函数内部作用域</p>
<p>E: enclosing 函数内部与内嵌函数之间</p>
<p>G: global 全局作用域</p>
<p>B： build-in 内置作用</p>
<p>python在函数里面的查找分为4种，称之为LEGB，也正是按照这是顺序来查找的</p>
<h4 id="45-字符串-quot-123-quot-转换成-123，不使用内置api，例如-int"><a href="#45-字符串-quot-123-quot-转换成-123，不使用内置api，例如-int" class="headerlink" title="45.字符串 &quot;123&quot; 转换成 123，不使用内置api，例如 int()"></a>45.字符串 <code>&quot;123&quot;</code> 转换成 <code>123</code>，不使用内置api，例如 <code>int()</code></h4><p>方法一： 利用 <code>str</code> 函数</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">atoi</span>(<span class="params">s</span>):</span></span><br><span class="line">    num = <span class="number">0</span></span><br><span class="line">    <span class="keyword">for</span> v <span class="keyword">in</span> s:</span><br><span class="line">        <span class="keyword">for</span> j <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">10</span>):</span><br><span class="line">            <span class="keyword">if</span> v == <span class="built_in">str</span>(j):</span><br><span class="line">                num = num * <span class="number">10</span> + j</span><br><span class="line">    <span class="keyword">return</span> num</span><br></pre></td></tr></table></figure>

<p>方法二： 利用 <code>ord</code> 函数</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">atoi</span>(<span class="params">s</span>):</span></span><br><span class="line">    num = <span class="number">0</span></span><br><span class="line">    <span class="keyword">for</span> v <span class="keyword">in</span> s:</span><br><span class="line">        num = num * <span class="number">10</span> + <span class="built_in">ord</span>(v) - <span class="built_in">ord</span>(<span class="string">&#x27;0&#x27;</span>)</span><br><span class="line">    <span class="keyword">return</span> num</span><br></pre></td></tr></table></figure>

<p>方法三: 利用 <code>eval</code> 函数</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">atoi</span>(<span class="params">s</span>):</span></span><br><span class="line">    num = <span class="number">0</span></span><br><span class="line">    <span class="keyword">for</span> v <span class="keyword">in</span> s:</span><br><span class="line">        t = <span class="string">&quot;%s * 1&quot;</span> % v</span><br><span class="line">        n = <span class="built_in">eval</span>(t)</span><br><span class="line">        num = num * <span class="number">10</span> + n</span><br><span class="line">    <span class="keyword">return</span> num</span><br></pre></td></tr></table></figure>

<p>方法四: 结合方法二，使用 <code>reduce</code>，一行解决</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">from</span> functools <span class="keyword">import</span> reduce</span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">atoi</span>(<span class="params">s</span>):</span></span><br><span class="line">    <span class="keyword">return</span> reduce(<span class="keyword">lambda</span> num, v: num * <span class="number">10</span> + <span class="built_in">ord</span>(v) - <span class="built_in">ord</span>(<span class="string">&#x27;0&#x27;</span>), s, <span class="number">0</span>)</span><br></pre></td></tr></table></figure>

<h4 id="46-Given-an-array-of-integers"><a href="#46-Given-an-array-of-integers" class="headerlink" title="46.Given an array of integers"></a>46.Given an array of integers</h4><p>给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。示例:给定nums = [2,7,11,15],target=9 因为 nums[0]+nums[1] = 2+7 =9,所以返回[0,1]</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">two_sum</span>(<span class="params">nums, target</span>):</span></span><br><span class="line">    <span class="string">&quot;&quot;&quot;</span></span><br><span class="line"><span class="string">    :type nums: List[int]</span></span><br><span class="line"><span class="string">    :type target: int</span></span><br><span class="line"><span class="string">    :rtype: List[int]</span></span><br><span class="line"><span class="string">    &quot;&quot;&quot;</span></span><br><span class="line">    <span class="keyword">for</span> i <span class="keyword">in</span> nums:</span><br><span class="line">        <span class="keyword">if</span> target - i <span class="keyword">in</span> nums <span class="keyword">and</span> i <span class="keyword">is</span> <span class="keyword">not</span> target-i:</span><br><span class="line">            <span class="keyword">return</span> [nums.index(i), nums.index(target - i)]</span><br><span class="line"></span><br><span class="line">nums_all = [<span class="number">2</span>, <span class="number">7</span>, <span class="number">11</span>, <span class="number">15</span>]</span><br><span class="line">target = <span class="number">9</span></span><br><span class="line">nums = two_sum(nums_all, target)</span><br><span class="line">print(nums)</span><br></pre></td></tr></table></figure>

<h4 id="47-有一个jsonline格式的文件file-txt大小约为10K"><a href="#47-有一个jsonline格式的文件file-txt大小约为10K" class="headerlink" title="47.有一个jsonline格式的文件file.txt大小约为10K"></a>47.有一个jsonline格式的文件file.txt大小约为10K</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">get_lines</span>():</span></span><br><span class="line">    <span class="keyword">with</span> <span class="built_in">open</span>(<span class="string">&#x27;file.txt&#x27;</span>,<span class="string">&#x27;rb&#x27;</span>) <span class="keyword">as</span> f:</span><br><span class="line">        <span class="keyword">return</span> f.readlines()</span><br><span class="line"></span><br><span class="line"><span class="keyword">if</span> __name__ == <span class="string">&#x27;__main__&#x27;</span>:</span><br><span class="line">    <span class="keyword">for</span> e <span class="keyword">in</span> get_lines():</span><br><span class="line">        process(e) <span class="comment"># 处理每一行数据</span></span><br></pre></td></tr></table></figure>

<p>现在要处理一个大小为10G的文件，但是内存只有4G，如果在只修改get_lines 函数而其他代码保持不变的情况下，应该如何实现？需要考虑的问题都有那些？</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">get_lines</span>():</span></span><br><span class="line">    <span class="keyword">with</span> <span class="built_in">open</span>(<span class="string">&#x27;file.txt&#x27;</span>,<span class="string">&#x27;rb&#x27;</span>) <span class="keyword">as</span> f:</span><br><span class="line">        <span class="keyword">for</span> i <span class="keyword">in</span> f:</span><br><span class="line">            <span class="keyword">yield</span> i</span><br></pre></td></tr></table></figure>

<p>Pandaaaa906提供的方法</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">from</span> mmap <span class="keyword">import</span> mmap</span><br><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">get_lines</span>(<span class="params">fp</span>):</span></span><br><span class="line">    <span class="keyword">with</span> <span class="built_in">open</span>(fp,<span class="string">&quot;r+&quot;</span>) <span class="keyword">as</span> f:</span><br><span class="line">        m = mmap(f.fileno(), <span class="number">0</span>)</span><br><span class="line">        tmp = <span class="number">0</span></span><br><span class="line">        <span class="keyword">for</span> i, char <span class="keyword">in</span> <span class="built_in">enumerate</span>(m):</span><br><span class="line">            <span class="keyword">if</span> char==<span class="string">b&quot;\n&quot;</span>:</span><br><span class="line">                <span class="keyword">yield</span> m[tmp:i+<span class="number">1</span>].decode()</span><br><span class="line">                tmp = i+<span class="number">1</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">if</span> __name__==<span class="string">&quot;__main__&quot;</span>:</span><br><span class="line">    <span class="keyword">for</span> i <span class="keyword">in</span> get_lines(<span class="string">&quot;fp_some_huge_file&quot;</span>):</span><br><span class="line">        print(i)</span><br></pre></td></tr></table></figure>

<p>要考虑的问题有：内存只有4G无法一次性读入10G文件，需要分批读入分批读入数据要记录每次读入数据的位置。分批每次读取数据的大小，太小会在读取操作花费过多时间。 <a target="_blank" rel="noopener" href="https://stackoverflow.com/questions/30294146/python-fastest-way-to-process-large-file">https://stackoverflow.com/questions/30294146/python-fastest-way-to-process-large-file</a></p>
<h4 id="48-返回该文件夹中所有文件的路径"><a href="#48-返回该文件夹中所有文件的路径" class="headerlink" title="48.返回该文件夹中所有文件的路径"></a>48.返回该文件夹中所有文件的路径</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">print_directory_contents</span>(<span class="params">sPath</span>):</span></span><br><span class="line"><span class="string">&quot;&quot;&quot;</span></span><br><span class="line"><span class="string">这个函数接收文件夹的名称作为输入参数</span></span><br><span class="line"><span class="string">返回该文件夹中文件的路径</span></span><br><span class="line"><span class="string">以及其包含文件夹中文件的路径</span></span><br><span class="line"><span class="string">&quot;&quot;&quot;</span></span><br><span class="line"><span class="keyword">import</span> os</span><br><span class="line"><span class="keyword">for</span> s_child <span class="keyword">in</span> os.listdir(s_path):</span><br><span class="line">    s_child_path = os.path.join(s_path, s_child)</span><br><span class="line">    <span class="keyword">if</span> os.path.isdir(s_child_path):</span><br><span class="line">        print_directory_contents(s_child_path)</span><br><span class="line">    <span class="keyword">else</span>:</span><br><span class="line">        print(s_child_path)</span><br></pre></td></tr></table></figure>

<h4 id="49-设计实现遍历目录与子目录，抓取-pyc文件"><a href="#49-设计实现遍历目录与子目录，抓取-pyc文件" class="headerlink" title="49.设计实现遍历目录与子目录，抓取.pyc文件"></a>49.设计实现遍历目录与子目录，抓取.pyc文件</h4><p>第一种方法：</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> os</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">get_files</span>(<span class="params"><span class="built_in">dir</span>,suffix</span>):</span></span><br><span class="line">    res = []</span><br><span class="line">    <span class="keyword">for</span> root,dirs,files <span class="keyword">in</span> os.walk(<span class="built_in">dir</span>):</span><br><span class="line">        <span class="keyword">for</span> filename <span class="keyword">in</span> files:</span><br><span class="line">            name,suf = os.path.splitext(filename)</span><br><span class="line">            <span class="keyword">if</span> suf == suffix:</span><br><span class="line">                res.append(os.path.join(root,filename))</span><br><span class="line"></span><br><span class="line">    print(res)</span><br><span class="line"></span><br><span class="line">get_files(<span class="string">&quot;./&quot;</span>,<span class="string">&#x27;.pyc&#x27;</span>)</span><br></pre></td></tr></table></figure>

<p>第二种方法：</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> os</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">pick</span>(<span class="params">obj</span>):</span></span><br><span class="line">    <span class="keyword">if</span> ob.endswith(<span class="string">&quot;.pyc&quot;</span>):</span><br><span class="line">        print(obj)</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">scan_path</span>(<span class="params">ph</span>):</span></span><br><span class="line">    file_list = os.listdir(ph)</span><br><span class="line">    <span class="keyword">for</span> obj <span class="keyword">in</span> file_list:</span><br><span class="line">        <span class="keyword">if</span> os.path.isfile(obj):</span><br><span class="line">            pick(obj)</span><br><span class="line">        <span class="keyword">elif</span> os.path.isdir(obj):</span><br><span class="line">            scan_path(obj)</span><br><span class="line"></span><br><span class="line"><span class="keyword">if</span> __name__==<span class="string">&#x27;__main__&#x27;</span>:</span><br><span class="line">    path = <span class="built_in">input</span>(<span class="string">&#x27;输入目录&#x27;</span>)</span><br><span class="line">    scan_path(path)</span><br></pre></td></tr></table></figure>

<p>第三种方法</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">from</span> glob <span class="keyword">import</span> iglob</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">func</span>(<span class="params">fp, postfix</span>):</span></span><br><span class="line">    <span class="keyword">for</span> i <span class="keyword">in</span> iglob(<span class="string">f&quot;<span class="subst">&#123;fp&#125;</span>/**/*<span class="subst">&#123;postfix&#125;</span>&quot;</span>, recursive=<span class="literal">True</span>):</span><br><span class="line">        print(i)</span><br><span class="line"></span><br><span class="line"><span class="keyword">if</span> __name__ == <span class="string">&quot;__main__&quot;</span>:</span><br><span class="line">    postfix = <span class="string">&quot;.pyc&quot;</span></span><br><span class="line">    func(<span class="string">&quot;K:\Python_script&quot;</span>, postfix)</span><br></pre></td></tr></table></figure>

<h4 id="50-输入日期，-判断这一天是这一年的第几天？"><a href="#50-输入日期，-判断这一天是这一年的第几天？" class="headerlink" title="50.输入日期， 判断这一天是这一年的第几天？"></a>50.输入日期， 判断这一天是这一年的第几天？</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> datetime</span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">dayofyear</span>():</span></span><br><span class="line">    year = <span class="built_in">input</span>(<span class="string">&quot;请输入年份: &quot;</span>)</span><br><span class="line">    month = <span class="built_in">input</span>(<span class="string">&quot;请输入月份: &quot;</span>)</span><br><span class="line">    day = <span class="built_in">input</span>(<span class="string">&quot;请输入天: &quot;</span>)</span><br><span class="line">    date1 = datetime.date(year=<span class="built_in">int</span>(year),month=<span class="built_in">int</span>(month),day=<span class="built_in">int</span>(day))</span><br><span class="line">    date2 = datetime.date(year=<span class="built_in">int</span>(year),month=<span class="number">1</span>,day=<span class="number">1</span>)</span><br><span class="line">    <span class="keyword">return</span> (date1-date2).days+<span class="number">1</span></span><br></pre></td></tr></table></figure>

<h4 id="51-打乱一个排好序的list对象alist？"><a href="#51-打乱一个排好序的list对象alist？" class="headerlink" title="51.打乱一个排好序的list对象alist？"></a>51.打乱一个排好序的list对象alist？</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> random</span><br><span class="line">alist = [<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>,<span class="number">4</span>,<span class="number">5</span>]</span><br><span class="line">random.shuffle(alist)</span><br><span class="line">print(alist)</span><br><span class="line"></span><br><span class="line"><span class="comment"># 下面这段代码是shuffle的实现</span></span><br><span class="line">items = <span class="built_in">list</span>(alist)</span><br><span class="line"><span class="keyword">for</span> i <span class="keyword">in</span> xrange(<span class="built_in">len</span>(alist)):</span><br><span class="line">    alist[i] = items.pop(self.randrange(<span class="built_in">len</span>(items)))</span><br></pre></td></tr></table></figure>

<h4 id="52-现有字典-d-‘a’-24-’g’-52-’i’-12-’k’-33-请按value值进行排序"><a href="#52-现有字典-d-‘a’-24-’g’-52-’i’-12-’k’-33-请按value值进行排序" class="headerlink" title="52.现有字典 d= {‘a’:24,’g’:52,’i’:12,’k’:33}请按value值进行排序?"></a>52.现有字典 d= {‘a’:24,’g’:52,’i’:12,’k’:33}请按value值进行排序?</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">sorted</span>(d.items(),key=<span class="keyword">lambda</span> x:x[<span class="number">1</span>])</span><br></pre></td></tr></table></figure>

<h4 id="53-字典推导式"><a href="#53-字典推导式" class="headerlink" title="53.字典推导式"></a>53.字典推导式</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 将字符串 &quot;k:1 |k1:2|k2:3|k3:4&quot;，处理成字典 &#123;k:1,k1:2,...&#125;</span></span><br><span class="line"><span class="comment"># d = &#123;key:value for (key,value) in iterable&#125;</span></span><br><span class="line">d = &#123;k:<span class="built_in">int</span>(v) <span class="keyword">for</span> t <span class="keyword">in</span> str1.split(<span class="string">&quot;|&quot;</span>) <span class="keyword">for</span> k, v <span class="keyword">in</span> (t.split(<span class="string">&quot;:&quot;</span>), )&#125;</span><br></pre></td></tr></table></figure>

<h4 id="54-请反转字符串-“aStr”"><a href="#54-请反转字符串-“aStr”" class="headerlink" title="54.请反转字符串 “aStr”?"></a>54.请反转字符串 “aStr”?</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">print(<span class="string">&quot;aStr&quot;</span>[::<span class="number">-1</span>])</span><br></pre></td></tr></table></figure>

<h4 id="55-请按alist中元素的age由大到小排序"><a href="#55-请按alist中元素的age由大到小排序" class="headerlink" title="55.请按alist中元素的age由大到小排序"></a>55.请按alist中元素的age由大到小排序</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">alist = [&#123;<span class="string">&#x27;name&#x27;</span>:<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;age&#x27;</span>:<span class="number">20</span>&#125;,&#123;<span class="string">&#x27;name&#x27;</span>:<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;age&#x27;</span>:<span class="number">30</span>&#125;,&#123;<span class="string">&#x27;name&#x27;</span>:<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;age&#x27;</span>:<span class="number">25</span>&#125;]</span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">sort_by_age</span>(<span class="params">list1</span>):</span></span><br><span class="line">    <span class="keyword">return</span> <span class="built_in">sorted</span>(alist, key=<span class="keyword">lambda</span> x:x[<span class="string">&#x27;age&#x27;</span>], reverse=<span class="literal">True</span>)</span><br></pre></td></tr></table></figure>

<h4 id="56-下面代码的输出结果将是什么？"><a href="#56-下面代码的输出结果将是什么？" class="headerlink" title="56.下面代码的输出结果将是什么？"></a>56.下面代码的输出结果将是什么？</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">list</span> = [<span class="string">&#x27;a&#x27;</span>,<span class="string">&#x27;b&#x27;</span>,<span class="string">&#x27;c&#x27;</span>,<span class="string">&#x27;d&#x27;</span>,<span class="string">&#x27;e&#x27;</span>]</span><br><span class="line">print(<span class="built_in">list</span>[<span class="number">10</span>:])</span><br></pre></td></tr></table></figure>

<p>代码将输出[],不会产生IndexError错误，就像所期望的那样，尝试用超出成员的个数的index来获取某个列表的成员。例如，尝试获取list[10]和之后的成员，会导致IndexError。然而，尝试获取列表的切片，开始的index超过了成员个数不会产生IndexError，而是仅仅返回一个空列表。这成为特别让人恶心的疑难杂症，因为运行的时候没有错误产生，导致Bug很难被追踪到。</p>
<h4 id="57-写一个列表生成式，产生一个公差为11的等差数列"><a href="#57-写一个列表生成式，产生一个公差为11的等差数列" class="headerlink" title="57.写一个列表生成式，产生一个公差为11的等差数列"></a>57.写一个列表生成式，产生一个公差为11的等差数列</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">print([x*<span class="number">11</span> <span class="keyword">for</span> x <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">10</span>)])</span><br></pre></td></tr></table></figure>

<h4 id="58-给定两个列表，怎么找出他们相同的元素和不同的元素？"><a href="#58-给定两个列表，怎么找出他们相同的元素和不同的元素？" class="headerlink" title="58.给定两个列表，怎么找出他们相同的元素和不同的元素？"></a>58.给定两个列表，怎么找出他们相同的元素和不同的元素？</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">list1 = [<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>]</span><br><span class="line">list2 = [<span class="number">3</span>,<span class="number">4</span>,<span class="number">5</span>]</span><br><span class="line">set1 = <span class="built_in">set</span>(list1)</span><br><span class="line">set2 = <span class="built_in">set</span>(list2)</span><br><span class="line">print(set1 &amp; set2)</span><br><span class="line">print(set1 ^ set2)</span><br></pre></td></tr></table></figure>

<h4 id="59-统计一个文本中单词频次最高的10个单词？"><a href="#59-统计一个文本中单词频次最高的10个单词？" class="headerlink" title="59.统计一个文本中单词频次最高的10个单词？"></a>59.统计一个文本中单词频次最高的10个单词？</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> re</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">test</span>(<span class="params">filepath</span>):</span></span><br><span class="line"></span><br><span class="line">    distone = &#123;&#125;</span><br><span class="line">    numTen = []</span><br><span class="line"></span><br><span class="line">    <span class="keyword">with</span> <span class="built_in">open</span>(filepath,<span class="string">&quot;r&quot;</span>,encoding=<span class="string">&quot;utf-8&quot;</span>) <span class="keyword">as</span> f:</span><br><span class="line">        <span class="keyword">for</span> line <span class="keyword">in</span> f:</span><br><span class="line">            line = re.sub(<span class="string">&quot;\W&quot;</span>,<span class="string">&quot;&quot;</span>,line)</span><br><span class="line">            lineone = line.split()</span><br><span class="line">            <span class="keyword">for</span> keyone <span class="keyword">in</span> lineone:</span><br><span class="line">                <span class="keyword">if</span> <span class="keyword">not</span> distone.get(keyone):</span><br><span class="line">                    distone[keyone]=<span class="number">1</span></span><br><span class="line">                <span class="keyword">else</span>:</span><br><span class="line">                    distone[keyone]+=<span class="number">1</span></span><br><span class="line">    numTen = <span class="built_in">sorted</span>(distone.items(),key=<span class="keyword">lambda</span> x:x[<span class="number">1</span>],reverse=<span class="literal">True</span>)[:<span class="number">10</span>]</span><br><span class="line">    numTen =[x[<span class="number">0</span>]<span class="keyword">for</span> x <span class="keyword">in</span> numTen]</span><br><span class="line">    <span class="keyword">return</span> numTen</span><br></pre></td></tr></table></figure>

<h4 id="60-给定一个任意长度数组，实现一个函数"><a href="#60-给定一个任意长度数组，实现一个函数" class="headerlink" title="60.给定一个任意长度数组，实现一个函数"></a>60.给定一个任意长度数组，实现一个函数</h4><p>让所有奇数都在偶数前面，而且奇数升序排列，偶数降序排序，如字符串’1982376455’,变成’1355798642’</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">func1</span>(<span class="params">l</span>):</span></span><br><span class="line">    <span class="keyword">if</span> <span class="built_in">isinstance</span>(l,<span class="built_in">str</span>):</span><br><span class="line">        l = <span class="built_in">list</span>(l)</span><br><span class="line">        l = [<span class="built_in">int</span>(i) <span class="keyword">for</span> i <span class="keyword">in</span> l]</span><br><span class="line">    l.sort(reverse=<span class="literal">True</span>)</span><br><span class="line">    <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="built_in">len</span>(l)):</span><br><span class="line">        <span class="keyword">if</span> l[i] % <span class="number">2</span>&gt;<span class="number">0</span>:</span><br><span class="line">            l.insert(<span class="number">0</span>,l.pop(i))</span><br><span class="line">    print(<span class="string">&#x27;&#x27;</span>.join(<span class="built_in">str</span>(e) <span class="keyword">for</span> e <span class="keyword">in</span> l))</span><br></pre></td></tr></table></figure>

<h4 id="61-写一个函数找出一个整数数组中，第二大的数"><a href="#61-写一个函数找出一个整数数组中，第二大的数" class="headerlink" title="61.写一个函数找出一个整数数组中，第二大的数"></a>61.写一个函数找出一个整数数组中，第二大的数</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">find_Second_large_num</span>(<span class="params">num_list</span>):</span></span><br><span class="line">    <span class="string">&quot;&quot;&quot;</span></span><br><span class="line"><span class="string">    找出数组第2大的数字</span></span><br><span class="line"><span class="string">    &quot;&quot;&quot;</span></span><br><span class="line">    <span class="comment">#直接排序，输出倒数第二个数即可</span></span><br><span class="line">    tmp_list = <span class="built_in">sorted</span>(num_list)</span><br><span class="line">    <span class="built_in">print</span> (<span class="string">&quot;Second_large_num is :&quot;</span>,tmp_list[<span class="number">-2</span>])</span><br><span class="line">    <span class="comment">#设置两个标志位一个存储最大数一个存储次大数</span></span><br><span class="line">    <span class="comment">#two 存储次大值，one存储最大值，遍历一次数组即可，先判断是否大于one，若大于将one的值给two，将num_list[i]的值给one,否则比较是否大于two,若大于直接将num_list[i]的值给two,否则pass</span></span><br><span class="line">    one = num_list[<span class="number">0</span>]</span><br><span class="line">    two = num_list[<span class="number">0</span>]</span><br><span class="line">    <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">1</span>,<span class="built_in">len</span>(num_list)):</span><br><span class="line">        <span class="keyword">if</span> num_list[i] &gt; one:</span><br><span class="line">            two = one</span><br><span class="line">            one = num_list[i]</span><br><span class="line">        <span class="keyword">elif</span> num_list[i] &gt; two:</span><br><span class="line">            two = num_list[i]</span><br><span class="line">        <span class="keyword">else</span>:</span><br><span class="line">            <span class="keyword">pass</span></span><br><span class="line">    print(<span class="string">&quot;Second_large_num is :&quot;</span>,two)</span><br><span class="line"><span class="keyword">if</span> __name__ == <span class="string">&#x27;__main___&#x27;</span>:</span><br><span class="line">    num_list = [<span class="number">34</span>,<span class="number">11</span>,<span class="number">23</span>,<span class="number">56</span>,<span class="number">78</span>,<span class="number">0</span>,<span class="number">9</span>,<span class="number">12</span>,<span class="number">3</span>,<span class="number">7</span>,<span class="number">5</span>]</span><br><span class="line">    find_Second_large_num(num_list)</span><br></pre></td></tr></table></figure>

<h4 id="62-阅读一下代码他们的输出结果是什么？"><a href="#62-阅读一下代码他们的输出结果是什么？" class="headerlink" title="62.阅读一下代码他们的输出结果是什么？"></a>62.阅读一下代码他们的输出结果是什么？</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">multi</span>():</span></span><br><span class="line">    <span class="keyword">return</span> [<span class="keyword">lambda</span> x : i*x <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">4</span>)]</span><br><span class="line">print([m(<span class="number">3</span>) <span class="keyword">for</span> m <span class="keyword">in</span> multi()])</span><br></pre></td></tr></table></figure>

<p>提示: 闭包，作用域 正确答案是[9,9,9,9]，而不是[0,3,6,9]产生的原因是Python的闭包的后期绑定导致的，这意味着在闭包中的变量是在内部函数被调用的时候被查找的，因为，最后函数被调用的时候，for循环已经完成, i 的值最后是3,因此每一个返回值的i都是3,所以最后的结果是[9,9,9,9] 这篇讲诉的很详细了 <a target="_blank" rel="noopener" href="https://www.cnblogs.com/shiqi17/p/9608195.html">https://www.cnblogs.com/shiqi17/p/9608195.html</a></p>
<h4 id="63-统计一段字符串中字符出现的次数"><a href="#63-统计一段字符串中字符出现的次数" class="headerlink" title="63.统计一段字符串中字符出现的次数"></a>63.统计一段字符串中字符出现的次数</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">count_str</span>(<span class="params">str_data</span>):</span></span><br><span class="line">    <span class="string">&quot;&quot;&quot;定义一个字符出现次数的函数&quot;&quot;&quot;</span></span><br><span class="line">    dict_str = &#123;&#125;</span><br><span class="line">    <span class="keyword">for</span> i <span class="keyword">in</span> str_data:</span><br><span class="line">        dict_str[i] = dict_str.get(i,<span class="number">0</span>)+<span class="number">1</span></span><br><span class="line">    <span class="keyword">return</span> dict_str</span><br><span class="line">dict_str = count_str(<span class="string">&quot;AAABBCCAC&quot;</span>)</span><br><span class="line">str_count_data = <span class="string">&quot;&quot;</span></span><br><span class="line"><span class="keyword">for</span> k,v <span class="keyword">in</span> dict_str.items():</span><br><span class="line">    str_count_data += k +<span class="built_in">str</span>(v)</span><br><span class="line">print(str_count_data)</span><br></pre></td></tr></table></figure>

<h4 id="64-super函数的具体用法和场景"><a href="#64-super函数的具体用法和场景" class="headerlink" title="64.super函数的具体用法和场景"></a>64.super函数的具体用法和场景</h4><p><a target="_blank" rel="noopener" href="https://python3-cookbook.readthedocs.io/zh_CN/latest/c08/p07_calling_method_on_parent_class.html">https://python3-cookbook.readthedocs.io/zh_CN/latest/c08/p07_calling_method_on_parent_class.html</a></p>
<h2 id="Python高级"><a href="#Python高级" class="headerlink" title="Python高级"></a>Python高级</h2><h3 id="元类"><a href="#元类" class="headerlink" title="元类"></a>元类</h3><h4 id="65-Python中类方法、类实例方法、静态方法有何区别？"><a href="#65-Python中类方法、类实例方法、静态方法有何区别？" class="headerlink" title="65.Python中类方法、类实例方法、静态方法有何区别？"></a>65.Python中类方法、类实例方法、静态方法有何区别？</h4><p>类方法: 是类对象的方法，在定义时需要在上方使用 @classmethod 进行装饰,形参为cls，表示类对象，类对象和实例对象都可调用</p>
<p>类实例方法: 是类实例化对象的方法,只有实例对象可以调用，形参为self,指代对象本身;</p>
<p>静态方法: 是一个任意函数，在其上方使用 @staticmethod 进行装饰，可以用对象直接调用，静态方法实际上跟该类没有太大关系</p>
<h4 id="66-遍历一个object的所有属性，并print每一个属性名？"><a href="#66-遍历一个object的所有属性，并print每一个属性名？" class="headerlink" title="66.遍历一个object的所有属性，并print每一个属性名？"></a>66.遍历一个object的所有属性，并print每一个属性名？</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br></pre></td><td class="code"><pre><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">Car</span>:</span></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">__init__</span>(<span class="params">self,name,loss</span>):</span> <span class="comment"># loss [价格，油耗，公里数]</span></span><br><span class="line">        self.name = name</span><br><span class="line">        self.loss = loss</span><br><span class="line"></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">getName</span>(<span class="params">self</span>):</span></span><br><span class="line">        <span class="keyword">return</span> self.name</span><br><span class="line"></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">getPrice</span>(<span class="params">self</span>):</span></span><br><span class="line"><span class="comment"># 获取汽车价格</span></span><br><span class="line">        <span class="keyword">return</span> self.loss[<span class="number">0</span>]</span><br><span class="line"></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">getLoss</span>(<span class="params">self</span>):</span></span><br><span class="line"><span class="comment"># 获取汽车损耗值</span></span><br><span class="line">        <span class="keyword">return</span> self.loss[<span class="number">1</span>] * self.loss[<span class="number">2</span>]</span><br><span class="line"></span><br><span class="line">Bmw = Car(<span class="string">&quot;宝马&quot;</span>,[<span class="number">60</span>,<span class="number">9</span>,<span class="number">500</span>]) <span class="comment"># 实例化一个宝马车对象</span></span><br><span class="line">print(<span class="built_in">getattr</span>(Bmw,<span class="string">&quot;name&quot;</span>)) <span class="comment"># 使用getattr()传入对象名字,属性值。</span></span><br><span class="line">print(<span class="built_in">dir</span>(Bmw)) <span class="comment"># 获Bmw所有的属性和方法</span></span><br></pre></td></tr></table></figure>

<h4 id="67-写一个类，并让它尽可能多的支持操作符"><a href="#67-写一个类，并让它尽可能多的支持操作符" class="headerlink" title="67.写一个类，并让它尽可能多的支持操作符?"></a>67.写一个类，并让它尽可能多的支持操作符?</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br></pre></td><td class="code"><pre><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">Array</span>:</span></span><br><span class="line">    __list = []</span><br><span class="line"></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">__init__</span>(<span class="params">self</span>):</span></span><br><span class="line">        <span class="built_in">print</span> <span class="string">&quot;constructor&quot;</span></span><br><span class="line"></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">__del__</span>(<span class="params">self</span>):</span></span><br><span class="line">        <span class="built_in">print</span> <span class="string">&quot;destruct&quot;</span></span><br><span class="line"></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">__str__</span>(<span class="params">self</span>):</span></span><br><span class="line">        <span class="keyword">return</span> <span class="string">&quot;this self-defined array class&quot;</span></span><br><span class="line"></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">__getitem__</span>(<span class="params">self,key</span>):</span></span><br><span class="line">        <span class="keyword">return</span> self.__list[key]</span><br><span class="line"></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">__len__</span>(<span class="params">self</span>):</span></span><br><span class="line">        <span class="keyword">return</span> <span class="built_in">len</span>(self.__list)</span><br><span class="line"></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">Add</span>(<span class="params">self,value</span>):</span></span><br><span class="line">        self.__list.append(value)</span><br><span class="line"></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">Remove</span>(<span class="params">self,index</span>):</span></span><br><span class="line">        <span class="keyword">del</span> self.__list[index]</span><br><span class="line"></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">DisplayItems</span>(<span class="params">self</span>):</span></span><br><span class="line">        <span class="built_in">print</span> <span class="string">&quot;show all items---&quot;</span></span><br><span class="line">        <span class="keyword">for</span> item <span class="keyword">in</span> self.__list:</span><br><span class="line">            <span class="built_in">print</span> item</span><br></pre></td></tr></table></figure>

<h4 id="68-介绍Cython，Pypy-Cpython-Numba各有什么缺点"><a href="#68-介绍Cython，Pypy-Cpython-Numba各有什么缺点" class="headerlink" title="68.介绍Cython，Pypy Cpython Numba各有什么缺点"></a>68.介绍Cython，Pypy Cpython Numba各有什么缺点</h4><p>CPython</p>
<p>CPython is Guido van Rossum’s reference version of the Python computing language. It’s most often called simply “Python”; speakers say “CPython” generally to distinguish it explicitly from other implementations.</p>
<p>CPython是使用最广的Python解释器。教程的所有代码也都在CPython下执行</p>
<p>IPython</p>
<p>IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强</p>
<p>Pypy</p>
<p>PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译（注意不是解释），所以可以显著提高Python代码的执行速度。 绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。如果你的代码要放到PyPy下执行，就需要了解PyPy和CPython的不同点</p>
<p>Jython</p>
<p>Jython是将Python code在JVM上面跑和调用java code的解释器。</p>
<h4 id="69-请描述抽象类和接口类的区别和联系"><a href="#69-请描述抽象类和接口类的区别和联系" class="headerlink" title="69.请描述抽象类和接口类的区别和联系"></a>69.请描述抽象类和接口类的区别和联系</h4><p>如前题 #30</p>
<h4 id="70-Python中如何动态获取和设置对象的属性？"><a href="#70-Python中如何动态获取和设置对象的属性？" class="headerlink" title="70.Python中如何动态获取和设置对象的属性？"></a>70.Python中如何动态获取和设置对象的属性？</h4><p>hasattr(), getattr(), setattr()</p>
<h3 id="内存管理与垃圾回收机制"><a href="#内存管理与垃圾回收机制" class="headerlink" title="内存管理与垃圾回收机制"></a>内存管理与垃圾回收机制</h3><h4 id="71-哪些操作会导致Python内存泄露，怎么处理？"><a href="#71-哪些操作会导致Python内存泄露，怎么处理？" class="headerlink" title="71.哪些操作会导致Python内存泄露，怎么处理？"></a>71.哪些操作会导致Python内存泄露，怎么处理？</h4><p>在使用KafkaProducer 进行消息读写的时候， 错误的配置了buffer_memory参数的值， 导致每次进行 类调用， 都导致客户端不断的重复写内存，并且因为最开始没有使用单例模式，导致内存不断上升，最后溢出。 解决办法就是修正错误的配置了buffer_memory参数的值 和使用单例</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">buffer_memory (<span class="built_in">int</span>): The total <span class="built_in">bytes</span> of memory the producer should use</span><br><span class="line">            to buffer records waiting to be sent to the server. If records are</span><br><span class="line">            sent faster than they can be delivered to the server the producer</span><br><span class="line">            will block up to max_block_ms, raising an exception on timeout.</span><br><span class="line">            In the current implementation, this setting <span class="keyword">is</span> an approximation.</span><br><span class="line">            Default: <span class="number">33554432</span> (<span class="number">32</span>MB)</span><br></pre></td></tr></table></figure>

<h4 id="72-关于内存溢出和内存泄漏的区别"><a href="#72-关于内存溢出和内存泄漏的区别" class="headerlink" title="72.关于内存溢出和内存泄漏的区别"></a>72.关于内存溢出和内存泄漏的区别</h4><p>内存溢出：（Out Of Memory—OOM）</p>
<p>系统已经不能再分配出你所需要的空间，比如你需要100M的空间，系统只剩90M了，这就叫内存溢出</p>
<p>内存泄漏： (Memory Leak)</p>
<p>强引用所指向的对象不会被回收，可能导致内存泄漏，虚拟机宁愿抛出OOM也不会去回收他指向的对象</p>
<h4 id="73-Python的内存管理机制及调优手段？"><a href="#73-Python的内存管理机制及调优手段？" class="headerlink" title="73.Python的内存管理机制及调优手段？"></a>73.Python的内存管理机制及调优手段？</h4><p>gc模块 <a target="_blank" rel="noopener" href="https://docs.python.org/3.7/library/gc.html">https://docs.python.org/3.7/library/gc.html</a></p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">gc.disable()  <span class="comment"># 暂停自动垃圾回收.</span></span><br><span class="line">gc.collect()  <span class="comment"># 执行一次完整的垃圾回收, 返回垃圾回收所找到无法到达的对象的数量.</span></span><br><span class="line">gc.set_threshold()  <span class="comment"># 设置Python垃圾回收的阈值.</span></span><br><span class="line">gc.set_debug()  <span class="comment"># 设置垃圾回收的调试标记. 调试信息会被写入std.err.</span></span><br></pre></td></tr></table></figure>

<p>Python有两种共存的内存管理机制: 引用计数和垃圾回收</p>
<p>垃圾回收机制:</p>
<ol>
<li><p>引用计数 PyObject</p>
<p>python里每一个东西都是对象，它们的核心就是一个结构体：PyObject</p>
<p>PyObject是每个对象必有的内容，其中ob_refcnt就是做为引用计数。当一个对象有新的引用时，它的ob_refcnt就会增加，当引用它的对象被删除，它的ob_refcnt就会减少</p>
<p>引用计数也是一种垃圾收集机制，而且也是一种最直观，最简单的垃圾收集技术。当 Python 的某个对象的引用计数降为 0 时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了。比如某个新建对象，它被分配给某个引用，对象的引用计数变为 1。如果引用被删除，对象的引用计数为 0，那么该对象就可以被垃圾回收。不过如果出现循环引用的话，引用计数机制就不再起有效的作用了</p>
</li>
<li><p>标记清除</p>
<p>标记-清除机制，顾名思义，首先标记对象（垃圾检测），然后清除垃圾（垃圾回收）。</p>
<p>首先初始所有对象标记为白色，并确定根节点对象（这些对象是不会被删除），标记它们为黑色（表示对象有效）。</p>
<p>将有效对象引用的对象标记为灰色（表示对象可达，但它们所引用的对象还没检查），检查完灰色对象引用的对象后，将灰色标记为黑色。</p>
<p>重复直到不存在灰色节点为止。最后白色结点都是需要清除的对象。</p>
</li>
<li><p>分代回收</p>
<p>从前面“标记-清除”这样的垃圾收集机制来看，这种垃圾收集机制所带来的额外操作实际上与系统中总的内存块的数量是相关的，当需要回收的内存块越多时，垃圾检测带来的额外操作就越多，而垃圾回收带来的额外操作就越少；反之，当需回收的内存块越少时，垃圾检测就将比垃圾回收带来更少的额外操作</p>
<p>1、新创建的对象做为0代</p>
<p>2、每执行一个【标记-删除】，存活的对象代数就+1</p>
<p>3、代数越高的对象（存活越持久的对象），进行【标记-删除】的时间间隔就越长。这个间隔，江湖人称阀值。</p>
</li>
<li><p>三种情况触发垃圾回收 1、调用gc.collect() 2、GC达到阀值时 3、程序退出时</p>
</li>
</ol>
<p>调优手段:</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">1.手动垃圾回收</span><br><span class="line"></span><br><span class="line">2.调高垃圾回收阈值</span><br><span class="line"></span><br><span class="line">3.避免循环引用</span><br></pre></td></tr></table></figure>

<h3 id="函数"><a href="#函数" class="headerlink" title="函数"></a>函数</h3><h4 id="74-什么是Hash（散列函数）？"><a href="#74-什么是Hash（散列函数）？" class="headerlink" title="74.什么是Hash（散列函数）？"></a>74.什么是Hash（散列函数）？</h4><p>Hash，一般翻译做“散列”，也有直接音译为”哈希“的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数</p>
<h4 id="75-编写函数的4个原则"><a href="#75-编写函数的4个原则" class="headerlink" title="75.编写函数的4个原则"></a>75.编写函数的4个原则</h4><p>1、函数设计要尽量短小，嵌套层次不宜过深。避免过长函数，嵌套最好能控制在3层之内</p>
<p>2、函数申明应该合理，简单，易于使用。除函数名能够够正确反映其大体功能外，参数的设计也应该简洁明了，参数个数不宜太多</p>
<p>3、函数参数设计应该考虑向下兼容。可以通过加入默认参数来避免退化</p>
<p>4、一个函数只做一件事，就要尽量保证抽象层级的一致性，所有语句尽量在一个粒度上。若在一个函数中处理多件事，不利于代码的重用</p>
<h4 id="76-函数调用参数的传递方式是值传递还是引用传递？"><a href="#76-函数调用参数的传递方式是值传递还是引用传递？" class="headerlink" title="76.函数调用参数的传递方式是值传递还是引用传递？"></a>76.函数调用参数的传递方式是值传递还是引用传递？</h4><p>python不允许程序员选择采用传值还是传引用。Python参数传递采用的肯定是“传对象引用”的方式。这种方式相当于传值和传引用的一种综合。如果函数收到的是一个可变对象（比如字典或者列表）的引用，就能修改对象的原始值－－相当于通过“传引用”来传递对象。如果函数收到的是一个不可变对象（比如数字、字符或者元组）的引用，就不能直接修改原始对象－－相当于通过“传值’来传递对象。</p>
<h4 id="77-如何在function里面设置一个全局变量"><a href="#77-如何在function里面设置一个全局变量" class="headerlink" title="77.如何在function里面设置一个全局变量"></a>77.如何在function里面设置一个全局变量</h4><p>global x</p>
<h4 id="78-带参数的装饰器"><a href="#78-带参数的装饰器" class="headerlink" title="78.带参数的装饰器?"></a>78.带参数的装饰器?</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">from</span> functools <span class="keyword">import</span> wraps</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">decorator</span>(<span class="params">*dargs, **dkwargs</span>):</span></span><br><span class="line"></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">params_wrapper</span>(<span class="params">func</span>):</span></span><br><span class="line"><span class="meta">        @wraps(func)</span></span><br><span class="line">        <span class="function"><span class="keyword">def</span> <span class="title">wrapper</span>(<span class="params">*args, **kwargs</span>):</span></span><br><span class="line">            func(*args, **kwargs)</span><br><span class="line">        <span class="keyword">return</span> wrapper</span><br><span class="line">    <span class="keyword">return</span> params_wrapper</span><br></pre></td></tr></table></figure>

<p>类装饰器</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line">class decorator(object):</span><br><span class="line">    def __init__(self, func):</span><br><span class="line">        self.func = func</span><br><span class="line"></span><br><span class="line">    def __call__(self, *args, **kwargs):</span><br><span class="line">        print(&#x27;before............&#x27;)</span><br><span class="line">        res = self.func(*args, **kwargs)</span><br><span class="line">        print(&#x27;after............&#x27;)</span><br><span class="line">        return res</span><br></pre></td></tr></table></figure>

<h4 id="79-递归函数停止的条件？"><a href="#79-递归函数停止的条件？" class="headerlink" title="79.递归函数停止的条件？"></a>79.递归函数停止的条件？</h4><p>递归的终止条件一般定义在递归函数内部，在递归调用前要做一个条件判断，根据判断的结果选择是继续调用自身，还是return；返回终止递归。</p>
<p>终止的条件：</p>
<p>1、判断递归的次数是否达到某一限定值</p>
<p>2、判断运算的结果是否达到某个范围等，根据设计的目的来选择</p>
<h3 id="设计模式"><a href="#设计模式" class="headerlink" title="设计模式"></a>设计模式</h3><h4 id="80-对设计模式的理解，简述你了解的设计模式？"><a href="#80-对设计模式的理解，简述你了解的设计模式？" class="headerlink" title="80.对设计模式的理解，简述你了解的设计模式？"></a>80.对设计模式的理解，简述你了解的设计模式？</h4><p>设计模式是经过总结，优化的，对我们经常会碰到的一些编程问题的可重用解决方案。一个设计模式并不像一个类或一个库那样能够直接作用于我们的代码，反之，设计模式更为高级，它是一种必须在特定情形下实现的一种方法模板。 常见的是工厂模式和单例模式</p>
<h4 id="81-python如何实现单例模式"><a href="#81-python如何实现单例模式" class="headerlink" title="81.python如何实现单例模式"></a>81.python如何实现单例模式</h4><p>第一种方法:使用装饰器</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">singleton</span>(<span class="params">cls</span>):</span></span><br><span class="line">    instances = &#123;&#125;</span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">wrapper</span>(<span class="params">*args, **kwargs</span>):</span></span><br><span class="line">        <span class="keyword">if</span> cls <span class="keyword">not</span> <span class="keyword">in</span> instances:</span><br><span class="line">            instances[cls] = cls(*args, **kwargs)</span><br><span class="line">        <span class="keyword">return</span> instances[cls]</span><br><span class="line">    <span class="keyword">return</span> wrapper</span><br><span class="line"><span class="meta">@singleton</span></span><br><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">Foo</span>(<span class="params"><span class="built_in">object</span></span>):</span></span><br><span class="line">    <span class="keyword">pass</span></span><br><span class="line">foo1 = Foo()</span><br><span class="line">foo2 = Foo()</span><br><span class="line"><span class="built_in">print</span> foo1 <span class="keyword">is</span> foo2 <span class="comment">#True</span></span><br></pre></td></tr></table></figure>

<p>第二种方法：使用基类 New 是真正创建实例对象的方法，所以重写基类的new 方法，以此保证创建对象的时候只生成一个实例</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">Singleton</span>(<span class="params"><span class="built_in">object</span></span>):</span></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">__new__</span>(<span class="params">cls,*args,**kwargs</span>):</span></span><br><span class="line">        <span class="keyword">if</span> <span class="keyword">not</span> <span class="built_in">hasattr</span>(cls,<span class="string">&#x27;_instance&#x27;</span>):</span><br><span class="line">            cls._instance = <span class="built_in">super</span>(Singleton,cls).__new__(cls,*args,**kwargs)</span><br><span class="line">        <span class="keyword">return</span> cls._instance</span><br><span class="line"></span><br><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">Foo</span>(<span class="params">Singleton</span>):</span></span><br><span class="line">    <span class="keyword">pass</span></span><br><span class="line"></span><br><span class="line">foo1 = Foo()</span><br><span class="line">foo2 = Foo()</span><br><span class="line"></span><br><span class="line"><span class="built_in">print</span> foo1 <span class="keyword">is</span> foo2 <span class="comment">#True</span></span><br></pre></td></tr></table></figure>

<h4 id="82-单例模式的应用场景有那些？"><a href="#82-单例模式的应用场景有那些？" class="headerlink" title="82.单例模式的应用场景有那些？"></a>82.单例模式的应用场景有那些？</h4><p>单例模式应用的场景一般发现在以下条件下： 资源共享的情况下，避免由于资源操作时导致的性能或损耗等，如日志文件，应用配置。 控制资源的情况下，方便资源之间的互相通信。如线程池等，</p>
<p>1.网站的计数器</p>
<p>2.应用配置</p>
<p>3.多线程池</p>
<p>4.数据库配置 数据库连接池</p>
<p>5.应用程序的日志应用…</p>
<h4 id="83-对装饰器的理解，并写出一个计时器记录方法执行性能的装饰器？"><a href="#83-对装饰器的理解，并写出一个计时器记录方法执行性能的装饰器？" class="headerlink" title="83.对装饰器的理解，并写出一个计时器记录方法执行性能的装饰器？"></a>83.对装饰器的理解，并写出一个计时器记录方法执行性能的装饰器？</h4><p>装饰器本质上是一个callable object ，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> time</span><br><span class="line"><span class="keyword">from</span> functools <span class="keyword">import</span> wraps</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">timeit</span>(<span class="params">func</span>):</span></span><br><span class="line"><span class="meta">    @wraps(func)</span></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">wrapper</span>(<span class="params">*args, **kwargs</span>):</span></span><br><span class="line">        start = time.clock()</span><br><span class="line">        ret = func(*args, **kwargs)</span><br><span class="line">        end = time.clock()</span><br><span class="line">        print(<span class="string">&#x27;used:&#x27;</span>,end-start)</span><br><span class="line">        <span class="keyword">return</span> ret</span><br><span class="line"></span><br><span class="line">    <span class="keyword">return</span> wrapper</span><br><span class="line"><span class="meta">@timeit</span></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">foo</span>():</span></span><br><span class="line">    print(<span class="string">&#x27;in foo()&#x27;</span>foo())</span><br></pre></td></tr></table></figure>

<h4 id="84-解释以下什么是闭包？"><a href="#84-解释以下什么是闭包？" class="headerlink" title="84.解释以下什么是闭包？"></a>84.解释以下什么是闭包？</h4><p>在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数以及用到的一些变量称之为闭包。</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">import functools</span><br><span class="line">def decorator(func):</span><br><span class="line">    @functools.wraps(func)</span><br><span class="line">    def wrapper(*args, **kwargs)</span><br><span class="line">        print &quot;start&quot;</span><br><span class="line">        return func(*args, **kwargs)</span><br><span class="line">    return wrapper</span><br></pre></td></tr></table></figure>

<h4 id="85-函数装饰器有什么作用？"><a href="#85-函数装饰器有什么作用？" class="headerlink" title="85.函数装饰器有什么作用？"></a>85.函数装饰器有什么作用？</h4><p>装饰器本质上是一个callable object，它可以在让其他函数在不需要做任何代码的变动的前提下增加额外的功能。装饰器的返回值也是一个函数的对象，它经常用于有切面需求的场景。比如：插入日志，性能测试，事务处理，缓存。权限的校验等场景，有了装饰器就可以抽离出大量的与函数功能本身无关的雷同代码并发并继续使用。 详细参考：<a target="_blank" rel="noopener" href="https://manjusaka.itscoder.com/2018/02/23/something-about-decorator/">https://manjusaka.itscoder.com/2018/02/23/something-about-decorator/</a></p>
<h4 id="86-生成器，迭代器的区别？"><a href="#86-生成器，迭代器的区别？" class="headerlink" title="86.生成器，迭代器的区别？"></a>86.生成器，迭代器的区别？</h4><p>迭代器是遵循迭代协议的对象。用户可以使用 iter() 以从任何序列得到迭代器（如 list, tuple, dictionary, set 等）。另一个方法则是创建一个另一种形式的迭代器 —— generator 。要获取下一个元素，则使用成员函数 next()（Python 2）或函数 next() function （Python 3） 。当没有元素时，则引发 StopIteration 此例外。若要实现自己的迭代器，则只要实现 next()（Python 2）或 <code>__next__</code>()（ Python 3）</p>
<p>生成器（Generator），只是在需要返回数据的时候使用yield语句。每次next()被调用时，生成器会返回它脱离的位置（它记忆语句最后一次执行的位置和所有的数据值）</p>
<p>区别： 生成器能做到迭代器能做的所有事，而且因为自动创建iter()和next()方法，生成器显得特别简洁，而且生成器也是高效的，使用生成器表达式取代列表解析可以同时节省内存。除了创建和保存程序状态的自动方法，当发生器终结时，还会自动抛出StopIteration异常。</p>
<p>官方介绍：<a target="_blank" rel="noopener" href="https://docs.python.org/3/tutorial/classes.html#iterators">https://docs.python.org/3/tutorial/classes.html#iterators</a></p>
<h4 id="87-X是什么类型"><a href="#87-X是什么类型" class="headerlink" title="87.X是什么类型?"></a>87.X是什么类型?</h4><figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">X= (i for i in range(10))</span><br><span class="line">X是 generator类型</span><br></pre></td></tr></table></figure>

<h4 id="88-请用一行代码-实现将1-N-的整数列表以3为单位分组"><a href="#88-请用一行代码-实现将1-N-的整数列表以3为单位分组" class="headerlink" title="88.请用一行代码 实现将1-N 的整数列表以3为单位分组"></a>88.请用一行代码 实现将1-N 的整数列表以3为单位分组</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">N =<span class="number">100</span></span><br><span class="line"><span class="built_in">print</span> ([[x <span class="keyword">for</span> x <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">1</span>,<span class="number">100</span>)] [i:i+<span class="number">3</span>] <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">0</span>,<span class="number">100</span>,<span class="number">3</span>)])</span><br></pre></td></tr></table></figure>

<h4 id="89-Python中yield的用法"><a href="#89-Python中yield的用法" class="headerlink" title="89.Python中yield的用法?"></a>89.Python中yield的用法?</h4><p>yield就是保存当前程序执行状态。你用for循环的时候，每次取一个元素的时候就会计算一次。用yield的函数叫generator,和iterator一样，它的好处是不用一次计算所有元素，而是用一次算一次，可以节省很多空间，generator每次计算需要上一次计算结果，所以用yield,否则一return，上次计算结果就没了</p>
<h3 id="面向对象"><a href="#面向对象" class="headerlink" title="面向对象"></a>面向对象</h3><h4 id="90-Python的魔法方法"><a href="#90-Python的魔法方法" class="headerlink" title="90.Python的魔法方法"></a>90.Python的魔法方法</h4><p><a target="_blank" rel="noopener" href="https://segmentfault.com/a/1190000007256392">https://segmentfault.com/a/1190000007256392</a></p>
<h4 id="91-谈谈你对面向对象的理解？"><a href="#91-谈谈你对面向对象的理解？" class="headerlink" title="91.谈谈你对面向对象的理解？"></a>91.谈谈你对面向对象的理解？</h4><p>在我理解,面向对象是向现实世界模型的自然延伸，这是一种“万物皆对象”的编程思想。在现实生活中的任何物体都可以归为一类事物，而每一个个体都是一类事物的实例。面向对象的编程是以对象为中心，以消息为驱动，所以程序=对象+消息。</p>
<p>面向对象有三大特性，封装、继承和多态。</p>
<p>封装就是将一类事物的属性和行为抽象成一个类，使其属性私有化，行为公开化，提高了数据的隐秘性的同时，使代码模块化。这样做使得代码的复用性更高。</p>
<p>继承则是进一步将一类事物共有的属性和行为抽象成一个父类，而每一个子类是一个特殊的父类–有父类的行为和属性，也有自己特有的行为和属性。这样做扩展了已存在的代码块，进一步提高了代码的复用性。</p>
<p>如果说封装和继承是为了使代码重用，那么多态则是为了实现接口重用。多态的一大作用就是为了解耦–为了解除父子类继承的耦合度。如果说继承中父子类的关系式IS-A的关系，那么接口和实现类之之间的关系式HAS-A。简单来说，多态就是允许父类引用(或接口)指向子类(或实现类)对象。很多的设计模式都是基于面向对象的多态性设计的。</p>
<p>总结一下，如果说封装和继承是面向对象的基础，那么多态则是面向对象最精髓的理论。掌握多态必先了解接口，只有充分理解接口才能更好的应用多态</p>
<h3 id="正则表达式"><a href="#正则表达式" class="headerlink" title="正则表达式"></a>正则表达式</h3><h4 id="92-请写出一段代码用正则匹配出ip？"><a href="#92-请写出一段代码用正则匹配出ip？" class="headerlink" title="92.请写出一段代码用正则匹配出ip？"></a>92.请写出一段代码用正则匹配出ip？</h4><h4 id="93-a-“abbbccc”，用正则匹配为abccc-不管有多少b，就出现一次？"><a href="#93-a-“abbbccc”，用正则匹配为abccc-不管有多少b，就出现一次？" class="headerlink" title="93.a = “abbbccc”，用正则匹配为abccc,不管有多少b，就出现一次？"></a>93.a = “abbbccc”，用正则匹配为abccc,不管有多少b，就出现一次？</h4><p>re.sub(r’b+’, ‘b’, ‘abbbccccc’)</p>
<h4 id="94-Python字符串查找和替换？"><a href="#94-Python字符串查找和替换？" class="headerlink" title="94.Python字符串查找和替换？"></a>94.Python字符串查找和替换？</h4><p>函数 说明</p>
<p>re.match(pat, s) 只从字符串s的头开始匹配，比如(‘123’, ‘12345’)匹配上了，而(‘123’,’01234’)就是没有匹配上，没有匹配上返回None，匹配上返回matchobject</p>
<p>re.search(pat, s) 从字符串s的任意位置都进行匹配，比如(‘123’,’01234’)就是匹配上了，只要s只能存在符合pat的连续字符串就算匹配上了，没有匹配上返回None，匹配上返回matchobject</p>
<p>re.sub(pat,newpat,s) 对字符串中s的包含的所有符合pat的连续字符串进行替换，如果newpat为str,那么就是替换为newpat,如果newpat是函数，那么就按照函数返回值替换。sub函数两个有默认值的参数分别是count表示最多只处理前几个匹配的字符串，默认为0表示全部处理；最后一个是flags，默认为0</p>
<h4 id="95-用Python匹配HTML-g-tag的时候，-lt-gt-和-lt-gt-有什么区别"><a href="#95-用Python匹配HTML-g-tag的时候，-lt-gt-和-lt-gt-有什么区别" class="headerlink" title="95.用Python匹配HTML g tag的时候，&lt;.&gt; 和 &lt;.*?&gt; 有什么区别"></a>95.用Python匹配HTML g tag的时候，&lt;.&gt; 和 &lt;.*?&gt; 有什么区别</h4><h4 id="96-正则表达式贪婪与非贪婪模式的区别？"><a href="#96-正则表达式贪婪与非贪婪模式的区别？" class="headerlink" title="96.正则表达式贪婪与非贪婪模式的区别？"></a>96.正则表达式贪婪与非贪婪模式的区别？</h4><p>如：String str=”abcaxc”; Patter p=”ab*c”;</p>
<p>贪婪匹配:正则表达式一般趋向于最大长度匹配，也就是所谓的贪婪匹配。如上面使用模式p匹配字符串str，结果就是匹配到：abcaxc(ab_c)。正则引擎默认是贪婪的，当出现”_”时,它会尽量去匹配尽可能长的字符串</p>
<p>非贪婪匹配：就是匹配到结果就好，就少的匹配字符。如上面使用模式p匹配字符串str，结果就是匹配到：abc(ab*c)。</p>
<h3 id="系统编程"><a href="#系统编程" class="headerlink" title="系统编程"></a>系统编程</h3><h4 id="97-进程总结"><a href="#97-进程总结" class="headerlink" title="97.进程总结"></a>97.进程总结</h4><p>进程：程序运行在操作系统上的一个实例，就称之为进程。进程需要相应的系统资源：内存、时间片、pid。 创建进程： 首先要导入multiprocessing中的Process： 创建一个Process对象; 创建Process对象时，可以传递参数;</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">p = Process(target=XXX,args=(<span class="built_in">tuple</span>,),kwargs=&#123;key:value&#125;)</span><br><span class="line">target = XXX 指定的任务函数，不用加(),</span><br><span class="line">args=(<span class="built_in">tuple</span>,)kwargs=&#123;key:value&#125;给任务函数传递的参数</span><br></pre></td></tr></table></figure>

<p>使用start()启动进程 结束进程 给子进程指定函数传递参数Demo</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> os</span><br><span class="line"><span class="keyword">from</span> mulitprocessing <span class="keyword">import</span> Process</span><br><span class="line"><span class="keyword">import</span> time</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">pro_func</span>(<span class="params">name,age,**kwargs</span>):</span></span><br><span class="line">    <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">5</span>):</span><br><span class="line">        print(<span class="string">&quot;子进程正在运行中，name=%s,age=%d,pid=%d&quot;</span>%(name,age,os.getpid()))</span><br><span class="line">        print(kwargs)</span><br><span class="line">        time.sleep(<span class="number">0.2</span>)</span><br><span class="line"><span class="keyword">if</span> __name__ ==<span class="string">&quot;__main__&quot;</span>:</span><br><span class="line">    <span class="comment">#创建Process对象</span></span><br><span class="line">    p = Process(target=pro_func,args=(<span class="string">&#x27;小明&#x27;</span>,<span class="number">18</span>),kwargs=&#123;<span class="string">&#x27;m&#x27;</span>:<span class="number">20</span>&#125;)</span><br><span class="line">    <span class="comment">#启动进程</span></span><br><span class="line">    p.start()</span><br><span class="line">    time.sleep(<span class="number">1</span>)</span><br><span class="line">    <span class="comment">#1秒钟之后，立刻结束子进程</span></span><br><span class="line">    p.terminate()</span><br><span class="line">    p.join()</span><br></pre></td></tr></table></figure>

<p>注意：进程间不共享全局变量</p>
<p>进程之间的通信-Queue</p>
<p>在初始化Queue()对象时（例如q=Queue(),若在括号中没有指定最大可接受的消息数量，获数量为负值时，那么就代表可接受的消息数量没有上限一直到内存尽头）</p>
<p>Queue.qsize():返回当前队列包含的消息数量</p>
<p>Queue.empty():如果队列为空，返回True，反之False</p>
<p>Queue.full():如果队列满了，返回True,反之False</p>
<p>Queue.get([block[,timeout]]):获取队列中的一条消息，然后将其从队列中移除，</p>
<p>block默认值为True。</p>
<p>如果block使用默认值，且没有设置timeout（单位秒),消息队列如果为空，此时程序将被阻塞（停在读中状态），直到消息队列读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出“Queue.Empty”异常：</p>
<p>Queue.get_nowait()相当于Queue.get(False)</p>
<p>Queue.put(item,[block[,timeout]]):将item消息写入队列，block默认值为True; 如果block使用默认值，且没有设置timeout（单位秒），消息队列如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息队列腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出”Queue.Full”异常 如果block值为False，消息队列如果没有空间可写入，则会立刻抛出”Queue.Full”异常; Queue.put_nowait(item):相当Queue.put(item,False)</p>
<p>进程间通信Demo:</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">from</span> multiprocessing <span class="keyword">import</span> Process,Queue</span><br><span class="line"><span class="keyword">import</span> os,time,random</span><br><span class="line"><span class="comment">#写数据进程执行的代码：</span></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">write</span>(<span class="params">q</span>):</span></span><br><span class="line">    <span class="keyword">for</span> value <span class="keyword">in</span> [<span class="string">&#x27;A&#x27;</span>,<span class="string">&#x27;B&#x27;</span>,<span class="string">&#x27;C&#x27;</span>]:</span><br><span class="line">        print(<span class="string">&quot;Put %s to queue...&quot;</span>,%value)</span><br><span class="line">        q.put(value)</span><br><span class="line">        time.sleep(random.random())</span><br><span class="line"><span class="comment">#读数据进程执行的代码</span></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">read</span>(<span class="params">q</span>):</span></span><br><span class="line">    <span class="keyword">while</span> <span class="literal">True</span>:</span><br><span class="line">        <span class="keyword">if</span> <span class="keyword">not</span> q.empty():</span><br><span class="line">            value = q.get(<span class="literal">True</span>)</span><br><span class="line">            print(<span class="string">&quot;Get %s from queue.&quot;</span>,%value)</span><br><span class="line">            time.sleep(random.random())</span><br><span class="line">        <span class="keyword">else</span>:</span><br><span class="line">            <span class="keyword">break</span></span><br><span class="line"><span class="keyword">if</span> __name__==<span class="string">&#x27;__main__&#x27;</span>:</span><br><span class="line">    <span class="comment">#父进程创建Queue，并传给各个子进程</span></span><br><span class="line">    q = Queue()</span><br><span class="line">    pw = Process(target=write,args=(q,))</span><br><span class="line">    pr = Process(target=read,args=(q,))</span><br><span class="line">    <span class="comment">#启动子进程pw ，写入：</span></span><br><span class="line">    pw.start()</span><br><span class="line">    <span class="comment">#等待pw结束</span></span><br><span class="line">    pw.join()</span><br><span class="line">    <span class="comment">#启动子进程pr，读取：</span></span><br><span class="line">    pr.start()</span><br><span class="line">    pr.join()</span><br><span class="line">    <span class="comment">#pr 进程里是死循环，无法等待其结束，只能强行终止:</span></span><br><span class="line">    print(<span class="string">&#x27;&#x27;</span>)</span><br><span class="line">    print(<span class="string">&#x27;所有数据都写入并且读完&#x27;</span>)</span><br></pre></td></tr></table></figure>

<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">进程池Pool</span><br></pre></td></tr></table></figure>

<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">#coding:utf-8</span></span><br><span class="line"><span class="keyword">from</span> multiprocessing <span class="keyword">import</span> Pool</span><br><span class="line"><span class="keyword">import</span> os,time,random</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">worker</span>(<span class="params">msg</span>):</span></span><br><span class="line">    t_start = time.time()</span><br><span class="line">    print(<span class="string">&quot;%s 开始执行，进程号为%d&quot;</span>%(msg,os.getpid()))</span><br><span class="line"><span class="comment"># random.random()随机生成0-1之间的浮点数</span></span><br><span class="line">    time.sleep(random.random()*<span class="number">2</span>)</span><br><span class="line">    t_stop = time.time()</span><br><span class="line">    print(msg,<span class="string">&quot;执行完毕，耗时%0.2f”%（t_stop-t_start))</span></span><br><span class="line"><span class="string"></span></span><br><span class="line"><span class="string">po = Pool(3)#定义一个进程池，最大进程数3</span></span><br><span class="line"><span class="string">for i in range(0,10):</span></span><br><span class="line"><span class="string">    po.apply_async(worker,(i,))</span></span><br><span class="line"><span class="string">print(&quot;</span>---start----<span class="string">&quot;)</span></span><br><span class="line"><span class="string">po.close()</span></span><br><span class="line"><span class="string">po.join()</span></span><br><span class="line"><span class="string">print(&quot;</span>----end----<span class="string">&quot;)</span></span><br></pre></td></tr></table></figure>

<p>进程池中使用Queue</p>
<p>如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue(),而不是multiprocessing.Queue(),否则会得到如下的错误信息：</p>
<p>RuntimeError： Queue objects should only be shared between processs through inheritance</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">from</span> multiprocessing <span class="keyword">import</span> Manager,Pool</span><br><span class="line"><span class="keyword">import</span> os,time,random</span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">reader</span>(<span class="params">q</span>):</span></span><br><span class="line">    print(<span class="string">&quot;reader 启动(%s),父进程为（%s)&quot;</span>%(os.getpid(),os.getpid()))</span><br><span class="line">    <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(q.qsize()):</span><br><span class="line">        print(<span class="string">&quot;reader 从Queue获取到消息:%s&quot;</span>%q.get(<span class="literal">True</span>))</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">writer</span>(<span class="params">q</span>):</span></span><br><span class="line">    print(<span class="string">&quot;writer 启动（%s),父进程为(%s)&quot;</span>%(os.getpid(),os.getpid()))</span><br><span class="line">    <span class="keyword">for</span> i ini <span class="string">&quot;itcast&quot;</span>:</span><br><span class="line">        q.put(i)</span><br><span class="line"><span class="keyword">if</span> __name__ == <span class="string">&quot;__main__&quot;</span>:</span><br><span class="line">    print(<span class="string">&quot;(%s)start&quot;</span>%os.getpid())</span><br><span class="line">    q = Manager().Queue()<span class="comment">#使用Manager中的Queue</span></span><br><span class="line">    po = Pool()</span><br><span class="line">    po.apply_async(wrtier,(q,))</span><br><span class="line">    time.sleep(<span class="number">1</span>)</span><br><span class="line">    po.apply_async(reader,(q,))</span><br><span class="line">    po.close()</span><br><span class="line">    po.join()</span><br><span class="line">    print(<span class="string">&quot;(%s)End&quot;</span>%os.getpid())</span><br></pre></td></tr></table></figure>

<h4 id="98-谈谈你对多进程，多线程，以及协程的理解，项目是否用？"><a href="#98-谈谈你对多进程，多线程，以及协程的理解，项目是否用？" class="headerlink" title="98.谈谈你对多进程，多线程，以及协程的理解，项目是否用？"></a>98.谈谈你对多进程，多线程，以及协程的理解，项目是否用？</h4><p>这个问题被问的概念相当之大，</p>
<p>进程：一个运行的程序（代码）就是一个进程，没有运行的代码叫程序，进程是系统资源分配的最小单位，进程拥有自己独立的内存空间，所有进程间数据不共享，开销大。</p>
<p>线程: cpu调度执行的最小单位，也叫执行路径，不能独立存在，依赖进程存在，一个进程至少有一个线程，叫主线程，而多个线程共享内存（数据共享，共享全局变量),从而极大地提高了程序的运行效率。</p>
<p>协程: 是一种用户态的轻量级线程，协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。协程调度时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。</p>
<p><a target="_blank" rel="noopener" href="https://www.jb51.net/article/142080.htm">https://www.jb51.net/article/142080.htm</a></p>
<h4 id="99-Python异步使用场景有那些？"><a href="#99-Python异步使用场景有那些？" class="headerlink" title="99.Python异步使用场景有那些？"></a>99.Python异步使用场景有那些？</h4><p>异步的使用场景:</p>
<p>1、 不涉及共享资源，获对共享资源只读，即非互斥操作</p>
<p>2、 没有时序上的严格关系</p>
<p>3、 不需要原子操作，或可以通过其他方式控制原子性</p>
<p>4、 常用于IO操作等耗时操作，因为比较影响客户体验和使用性能</p>
<p>5、 不影响主线程逻辑</p>
<h4 id="100-多线程共同操作同一个数据互斥锁同步？"><a href="#100-多线程共同操作同一个数据互斥锁同步？" class="headerlink" title="100.多线程共同操作同一个数据互斥锁同步？"></a>100.多线程共同操作同一个数据互斥锁同步？</h4><figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> threading</span><br><span class="line"><span class="keyword">import</span> time</span><br><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">MyThread</span>(<span class="params">threading.Thread</span>):</span></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">run</span>(<span class="params">self</span>):</span></span><br><span class="line">        <span class="keyword">global</span> num</span><br><span class="line">        time.sleep(<span class="number">1</span>)</span><br><span class="line"></span><br><span class="line">        <span class="keyword">if</span> mutex.acquire(<span class="number">1</span>):</span><br><span class="line">            num +=<span class="number">1</span></span><br><span class="line">            msg = self.name + <span class="string">&#x27;set num to &#x27;</span> +<span class="built_in">str</span>(num)</span><br><span class="line">            <span class="built_in">print</span> msg</span><br><span class="line">            mutex.release()</span><br><span class="line">num = <span class="number">0</span></span><br><span class="line">mutex = threading.Lock()</span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">test</span>():</span></span><br><span class="line">    <span class="keyword">for</span> i <span class="keyword">in</span> <span class="built_in">range</span>(<span class="number">5</span>):</span><br><span class="line">        t = MyThread()</span><br><span class="line">        t.start()</span><br><span class="line"><span class="keyword">if</span> __name__==<span class="string">&quot;__main__&quot;</span>:</span><br><span class="line">    test()</span><br></pre></td></tr></table></figure>

<h4 id="101-什么是多线程竞争？"><a href="#101-什么是多线程竞争？" class="headerlink" title="101.什么是多线程竞争？"></a>101.什么是多线程竞争？</h4><p>线程是非独立的，同一个进程里线程是数据共享的，当各个线程访问数据资源时会出现竞争状态即：数据几乎同步会被多个线程占用，造成数据混乱，即所谓的线程不安全</p>
<p>那么怎么解决多线程竞争问题？—锁</p>
<p>锁的好处： 确保了某段关键代码（共享数据资源）只能由一个线程从头到尾完整地执行能解决多线程资源竞争下的原子操作问题。</p>
<p>锁的坏处： 阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了</p>
<p>锁的致命问题: 死锁</p>
<h4 id="102-请介绍一下Python的线程同步？"><a href="#102-请介绍一下Python的线程同步？" class="headerlink" title="102.请介绍一下Python的线程同步？"></a>102.请介绍一下Python的线程同步？</h4><p>一、 setDaemon(False) 当一个进程启动之后，会默认产生一个主线程，因为线程是程序执行的最小单位，当设置多线程时，主线程会创建多个子线程，在Python中，默认情况下就是setDaemon(False),主线程执行完自己的任务以后，就退出了，此时子线程会继续执行自己的任务，直到自己的任务结束。</p>
<p>例子</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> threading</span><br><span class="line"><span class="keyword">import</span> time</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">thread</span>():</span></span><br><span class="line">    time.sleep(<span class="number">2</span>)</span><br><span class="line">    print(<span class="string">&#x27;---子线程结束---&#x27;</span>)</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">main</span>():</span></span><br><span class="line">    t1 = threading.Thread(target=thread)</span><br><span class="line">    t1.start()</span><br><span class="line">    print(<span class="string">&#x27;---主线程--结束&#x27;</span>)</span><br><span class="line"></span><br><span class="line"><span class="keyword">if</span> __name__ ==<span class="string">&#x27;__main__&#x27;</span>:</span><br><span class="line">    main()</span><br><span class="line"><span class="comment">#执行结果</span></span><br><span class="line">---主线程--结束</span><br><span class="line">---子线程结束---</span><br></pre></td></tr></table></figure>

<p>二、 setDaemon（True) 当我们使用setDaemon(True)时，这是子线程为守护线程，主线程一旦执行结束，则全部子线程被强制终止</p>
<p>例子</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> threading</span><br><span class="line"><span class="keyword">import</span> time</span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">thread</span>():</span></span><br><span class="line">    time.sleep(<span class="number">2</span>)</span><br><span class="line">    print(’---子线程结束---<span class="string">&#x27;)</span></span><br><span class="line"><span class="string">def main():</span></span><br><span class="line"><span class="string">    t1 = threading.Thread(target=thread)</span></span><br><span class="line"><span class="string">    t1.setDaemon(True)#设置子线程守护主线程</span></span><br><span class="line"><span class="string">    t1.start()</span></span><br><span class="line"><span class="string">    print(&#x27;</span>---主线程结束---<span class="string">&#x27;)</span></span><br><span class="line"><span class="string"></span></span><br><span class="line"><span class="string">if __name__ ==&#x27;</span>__main__<span class="string">&#x27;:</span></span><br><span class="line"><span class="string">    main()</span></span><br><span class="line"><span class="string">#执行结果</span></span><br><span class="line"><span class="string">---主线程结束--- #只有主线程结束，子线程来不及执行就被强制结束</span></span><br></pre></td></tr></table></figure>

<p>三、 join（线程同步) join 所完成的工作就是线程同步，即主线程任务结束以后，进入堵塞状态，一直等待所有的子线程结束以后，主线程再终止。</p>
<p>当设置守护线程时，含义是主线程对于子线程等待timeout的时间将会杀死该子线程，最后退出程序，所以说，如果有10个子线程，全部的等待时间就是每个timeout的累加和，简单的来说，就是给每个子线程一个timeout的时间，让他去执行，时间一到，不管任务有没有完成，直接杀死。</p>
<p>没有设置守护线程时，主线程将会等待timeout的累加和这样的一段时间，时间一到，主线程结束，但是并没有杀死子线程，子线程依然可以继续执行，直到子线程全部结束，程序退出。</p>
<p>例子</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">import</span> threading</span><br><span class="line"><span class="keyword">import</span> time</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">thread</span>():</span></span><br><span class="line">    time.sleep(<span class="number">2</span>)</span><br><span class="line">    print(<span class="string">&#x27;---子线程结束---&#x27;</span>)</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">main</span>():</span></span><br><span class="line">    t1 = threading.Thread(target=thread)</span><br><span class="line">    t1.setDaemon(<span class="literal">True</span>)</span><br><span class="line">    t1.start()</span><br><span class="line">    t1.join(timeout=<span class="number">1</span>)<span class="comment">#1 线程同步，主线程堵塞1s 然后主线程结束，子线程继续执行</span></span><br><span class="line">                        <span class="comment">#2 如果不设置timeout参数就等子线程结束主线程再结束</span></span><br><span class="line">                        <span class="comment">#3 如果设置了setDaemon=True和timeout=1主线程等待1s后会强制杀死子线程，然后主线程结束</span></span><br><span class="line">    print(<span class="string">&#x27;---主线程结束---&#x27;</span>)</span><br><span class="line"></span><br><span class="line"><span class="keyword">if</span> __name__==<span class="string">&#x27;__main___&#x27;</span>:</span><br><span class="line">    main()</span><br></pre></td></tr></table></figure>

<h4 id="103-解释以下什么是锁，有哪几种锁？"><a href="#103-解释以下什么是锁，有哪几种锁？" class="headerlink" title="103.解释以下什么是锁，有哪几种锁？"></a>103.解释以下什么是锁，有哪几种锁？</h4><p>锁(Lock)是python提供的对线程控制的对象。有互斥锁，可重入锁，死锁。</p>
<h4 id="104-什么是死锁？"><a href="#104-什么是死锁？" class="headerlink" title="104.什么是死锁？"></a>104.什么是死锁？</h4><p>若干子线程在系统资源竞争时，都在等待对方对某部分资源解除占用状态，结果是谁也不愿先解锁，互相干等着，程序无法执行下去，这就是死锁。</p>
<p>GIL锁 全局解释器锁（只在cpython里才有）</p>
<p>作用： 限制多线程同时执行，保证同一时间只有一个线程执行，所以cpython里的多线程其实是伪多线程！</p>
<p>所以python里常常使用协程技术来代替多线程，协程是一种更轻量级的线程。</p>
<p>进程和线程的切换时由系统决定，而协程由我们程序员自己决定，而模块gevent下切换是遇到了耗时操作时才会切换</p>
<p>三者的关系：进程里有线程，线程里有协程。</p>
<h4 id="105-多线程交互访问数据，如果访问到了就不访问了？"><a href="#105-多线程交互访问数据，如果访问到了就不访问了？" class="headerlink" title="105.多线程交互访问数据，如果访问到了就不访问了？"></a>105.多线程交互访问数据，如果访问到了就不访问了？</h4><p>怎么避免重读？</p>
<p>创建一个已访问数据列表，用于存储已经访问过的数据，并加上互斥锁，在多线程访问数据的时候先查看数据是否在已访问的列表中，若已存在就直接跳过。</p>
<h4 id="106-什么是线程安全，什么是互斥锁？"><a href="#106-什么是线程安全，什么是互斥锁？" class="headerlink" title="106.什么是线程安全，什么是互斥锁？"></a>106.什么是线程安全，什么是互斥锁？</h4><p>每个对象都对应于一个可称为’互斥锁‘的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。</p>
<p>同一进程中的多线程之间是共享系统资源的，多个线程同时对一个对象进行操作，一个线程操作尚未结束，另一线程已经对其进行操作，导致最终结果出现错误，此时需要对被操作对象添加互斥锁，保证每个线程对该对象的操作都得到正确的结果。</p>
<h4 id="107-说说下面几个概念：同步，异步，阻塞，非阻塞？"><a href="#107-说说下面几个概念：同步，异步，阻塞，非阻塞？" class="headerlink" title="107.说说下面几个概念：同步，异步，阻塞，非阻塞？"></a>107.说说下面几个概念：同步，异步，阻塞，非阻塞？</h4><p>同步： 多个任务之间有先后顺序执行，一个执行完下个才能执行。</p>
<p>异步： 多个任务之间没有先后顺序，可以同时执行，有时候一个任务可能要在必要的时候获取另一个同时执行的任务的结果，这个就叫回调！</p>
<p>阻塞： 如果卡住了调用者，调用者不能继续往下执行，就是说调用者阻塞了。</p>
<p>非阻塞： 如果不会卡住，可以继续执行，就是说非阻塞的。</p>
<p>同步异步相对于多任务而言，阻塞非阻塞相对于代码执行而言。</p>
<h4 id="108-什么是僵尸进程和孤儿进程？怎么避免僵尸进程？"><a href="#108-什么是僵尸进程和孤儿进程？怎么避免僵尸进程？" class="headerlink" title="108.什么是僵尸进程和孤儿进程？怎么避免僵尸进程？"></a>108.什么是僵尸进程和孤儿进程？怎么避免僵尸进程？</h4><p>孤儿进程： 父进程退出，子进程还在运行的这些子进程都是孤儿进程，孤儿进程将被init 进程（进程号为1）所收养，并由init 进程对他们完成状态收集工作。</p>
<p>僵尸进程： 进程使用fork 创建子进程，如果子进程退出，而父进程并没有调用wait 获waitpid 获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中的这些进程是僵尸进程。</p>
<p>避免僵尸进程的方法：</p>
<p>1.fork 两次用孙子进程去完成子进程的任务</p>
<p>2.用wait()函数使父进程阻塞</p>
<p>3.使用信号量，在signal handler 中调用waitpid,这样父进程不用阻塞</p>
<h4 id="109-python中进程与线程的使用场景？"><a href="#109-python中进程与线程的使用场景？" class="headerlink" title="109.python中进程与线程的使用场景？"></a>109.python中进程与线程的使用场景？</h4><p>多进程适合在CPU密集操作（cpu操作指令比较多，如位多的的浮点运算）。</p>
<p>多线程适合在IO密性型操作（读写数据操作比多的的，比如爬虫）</p>
<h4 id="110-线程是并发还是并行，进程是并发还是并行？"><a href="#110-线程是并发还是并行，进程是并发还是并行？" class="headerlink" title="110.线程是并发还是并行，进程是并发还是并行？"></a>110.线程是并发还是并行，进程是并发还是并行？</h4><p>线程是并发，进程是并行;</p>
<p>进程之间互相独立，是系统分配资源的最小单位，同一个线程中的所有线程共享资源。</p>
<h4 id="111-并行-parallel-和并发（concurrency"><a href="#111-并行-parallel-和并发（concurrency" class="headerlink" title="111.并行(parallel)和并发（concurrency)?"></a>111.并行(parallel)和并发（concurrency)?</h4><p>并行： 同一时刻多个任务同时在运行</p>
<p>不会在同一时刻同时运行，存在交替执行的情况。</p>
<p>实现并行的库有： multiprocessing</p>
<p>实现并发的库有: threading</p>
<p>程序需要执行较多的读写、请求和回复任务的需要大量的IO操作，IO密集型操作使用并发更好。</p>
<p>CPU运算量大的程序，使用并行会更好</p>
<p>concurrent.futures 中ThreadPoolExecutor ProcessPoolExecutor 封装multiprocessing， threading</p>
<h4 id="112-IO密集型和CPU密集型区别？"><a href="#112-IO密集型和CPU密集型区别？" class="headerlink" title="112.IO密集型和CPU密集型区别？"></a>112.IO密集型和CPU密集型区别？</h4><p>IO密集型： 系统运行，大部分的状况是CPU在等 I/O（硬盘/内存）的读/写</p>
<p>CPU密集型： 大部分时间用来做计算，逻辑判断等CPU动作的程序称之CPU密集型。</p>
<h4 id="113-python-asyncio的原理？"><a href="#113-python-asyncio的原理？" class="headerlink" title="113.python asyncio的原理？"></a>113.python asyncio的原理？</h4><p>asyncio这个库就是使用python的yield这个可以打断保存当前函数的上下文的机制， 封装好了selector 摆脱掉了复杂的回调关系</p>
<h3 id="网络编程"><a href="#网络编程" class="headerlink" title="网络编程"></a>网络编程</h3><h4 id="114-怎么实现强行关闭客户端和服务器之间的连接"><a href="#114-怎么实现强行关闭客户端和服务器之间的连接" class="headerlink" title="114.怎么实现强行关闭客户端和服务器之间的连接?"></a>114.怎么实现强行关闭客户端和服务器之间的连接?</h4><h4 id="115-简述TCP和UDP的区别以及优缺点"><a href="#115-简述TCP和UDP的区别以及优缺点" class="headerlink" title="115.简述TCP和UDP的区别以及优缺点?"></a>115.简述TCP和UDP的区别以及优缺点?</h4><p>UDP是面向无连接的通讯协议，UDP数据包括目的端口号和源端口号信息。</p>
<p>优点：UDP速度快、操作简单、要求系统资源较少，由于通讯不需要连接，可以实现广播发送</p>
<p>缺点：UDP传送数据前并不与对方建立连接，对接收到的数据也不发送确认信号，发送端不知道数据是否会正确接收，也不重复发送，不可靠。</p>
<p>TCP是面向连接的通讯协议，通过三次握手建立连接，通讯完成时四次挥手</p>
<p>优点：TCP在数据传递时，有确认、窗口、重传、阻塞等控制机制，能保证数据正确性，较为可靠。</p>
<p>缺点：TCP相对于UDP速度慢一点，要求系统资源较多</p>
<h4 id="116-简述浏览器通过WSGI请求动态资源的过程"><a href="#116-简述浏览器通过WSGI请求动态资源的过程" class="headerlink" title="116.简述浏览器通过WSGI请求动态资源的过程?"></a>116.简述浏览器通过WSGI请求动态资源的过程?</h4><p>1、浏览器发送请求给web服务器；</p>
<p>2、web服务器接收到动态请求后通过wsgi协议调用框架；</p>
<p>3、框架根据请求信息向数据库获取动态数据；</p>
<p>4、框架将获取的动态数据插入模板文件，构成响应体；</p>
<p>5、框架将响应体数据、响应状态码和说明、响应头信息返回给web服务器；</p>
<p>6、web服务器接收到框架提供的数据后将数据按照响应报文的格式编码发送给浏览器；</p>
<p>7、浏览器接收到相应数据后，通过解码并按照http协议格式显示在界面上。</p>
<h4 id="117-描述用浏览器访问www-baidu-com的过程"><a href="#117-描述用浏览器访问www-baidu-com的过程" class="headerlink" title="117.描述用浏览器访问www.baidu.com的过程"></a>117.描述用浏览器访问<a target="_blank" rel="noopener" href="http://www.baidu.com的过程/">www.baidu.com的过程</a></h4><p>浏览器访问百度</p>
<p>1、先要解析出baidu.com对应的地址</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line">1.1 先通过arp获取默认网关（交换机）的mac地址（mac地址指的是物理地址）（UDP广播）</span><br><span class="line"></span><br><span class="line">1.2 组织数据发送给默认网关(ip是dns服务器的ip，mac是默认网关的mac地址)</span><br><span class="line"></span><br><span class="line">1.3 默认网关（交换机）拥有转发数据的能力，把数据转发给路由器</span><br><span class="line"></span><br><span class="line">1.4 路由器根据自己的路由协议，选择一个合适的较快的路径转发数据给目的网关</span><br><span class="line"></span><br><span class="line">1.5 目的网关(dns服务器所在的网关)把数据转发给dns服务器</span><br><span class="line"></span><br><span class="line">1.6 dns服务器查询解析出baidu.com对应的IP地址，并将它原路返回给请求这个域名的client</span><br></pre></td></tr></table></figure>

<p>2、得到了baidu.com对应的ip地址后，会发送tcp三次握手进行连接</p>
<p>3、使用http协议发送请求数据给web服务器</p>
<p>4、web服务器收到数据请求之后，通过查询自己的服务器得到相应的结果，原路返回给浏览器</p>
<p>5、浏览器接收到数据后，通过浏览器自己的渲染功能来显示这个网页</p>
<p>6、浏览器关闭连接，即四次挥手</p>
<h4 id="118-Post和Get请求的区别"><a href="#118-Post和Get请求的区别" class="headerlink" title="118.Post和Get请求的区别?"></a>118.Post和Get请求的区别?</h4><p>1.GET是从服务器上获取数据，POST是向服务器传送数据</p>
<p>2.在客户端，GET方式在通过URL提交数据，数据在URL中可以看到，POST方式，数据放置在HTML——HEADER内提交</p>
<p>3.对于GET方式，服务器端用Request.QueryString获取变量的值，对于POST方式，服务器端用Request.Form获取提交的数据</p>
<p>MORE ？</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line">浏览器的GET和POST</span><br><span class="line"></span><br><span class="line">接口中的GET和POST</span><br><span class="line"></span><br><span class="line">关于安全性</span><br><span class="line"></span><br><span class="line">关于编码</span><br><span class="line"></span><br><span class="line">浏览器的POST需要发两个请求吗？</span><br><span class="line"></span><br><span class="line">关于URL的长度</span><br></pre></td></tr></table></figure>

<h4 id="119-列出你知道的HTTP协议的状态码，说出表示什么意思？"><a href="#119-列出你知道的HTTP协议的状态码，说出表示什么意思？" class="headerlink" title="119.列出你知道的HTTP协议的状态码，说出表示什么意思？"></a>119.列出你知道的HTTP协议的状态码，说出表示什么意思？</h4><h4 id="120-请简单说一下三次握手和四次挥手？"><a href="#120-请简单说一下三次握手和四次挥手？" class="headerlink" title="120.请简单说一下三次握手和四次挥手？"></a>120.请简单说一下三次握手和四次挥手？</h4><p><a target="_blank" rel="noopener" href="https://blog.csdn.net/qq_38950316/article/details/81087809">https://blog.csdn.net/qq_38950316/article/details/81087809</a></p>
<h4 id="121-为什么客户端在TIME-WAIT状态必须等待2MSL的时间？"><a href="#121-为什么客户端在TIME-WAIT状态必须等待2MSL的时间？" class="headerlink" title="121.为什么客户端在TIME-WAIT状态必须等待2MSL的时间？"></a>121.为什么客户端在TIME-WAIT状态必须等待2MSL的时间？</h4><p>RFC 793中规定MSL为2分钟，实际应用中常用的是30秒，1分钟和2分钟等</p>
<p>1）为了保证客户端发送的最后一个ACK报文段能够达到服务器。 这个ACK报文段可能丢失，因而使处在LAST-ACK状态的服务器收不到确认。服务器会超时重传FIN+ACK报文段，客户端就能在2MSL时间内收到这个重传的FIN+ACK报文段，接着客户端重传一次确认，重启计时器。最好，客户端和服务器都正常进入到CLOSED状态。如果客户端在TIME-WAIT状态不等待一段时间，而是再发送完ACK报文后立即释放连接，那么就无法收到服务器重传的FIN+ACK报文段，因而也不会再发送一次确认报文。这样，服务器就无法按照正常步骤进入CLOSED状态。</p>
<p>2）防止已失效的连接请求报文段出现在本连接中。客户端在发送完最后一个ACK确认报文段后，再经过时间2MSL，就可以使本连接持续的时间内所产生的所有报文段都从网络中消失。这样就可以使下一个新的连接中不会出现这种旧的连接请求报文段。</p>
<h4 id="122-说说HTTP和HTTPS区别？"><a href="#122-说说HTTP和HTTPS区别？" class="headerlink" title="122.说说HTTP和HTTPS区别？"></a>122.说说HTTP和HTTPS区别？</h4><p><a target="_blank" rel="noopener" href="https://www.cnblogs.com/jesse131/p/9080925.html">https://www.cnblogs.com/jesse131/p/9080925.html</a></p>
<h4 id="123-谈一下HTTP协议以及协议头部中表示数据类型的字段？"><a href="#123-谈一下HTTP协议以及协议头部中表示数据类型的字段？" class="headerlink" title="123.谈一下HTTP协议以及协议头部中表示数据类型的字段？"></a>123.谈一下HTTP协议以及协议头部中表示数据类型的字段？</h4><h4 id="124-HTTP请求方法都有什么？"><a href="#124-HTTP请求方法都有什么？" class="headerlink" title="124.HTTP请求方法都有什么？"></a>124.HTTP请求方法都有什么？</h4><h4 id="125-使用Socket套接字需要传入哪些参数-？"><a href="#125-使用Socket套接字需要传入哪些参数-？" class="headerlink" title="125.使用Socket套接字需要传入哪些参数 ？"></a>125.使用Socket套接字需要传入哪些参数 ？</h4><h4 id="126-HTTP常见请求头？"><a href="#126-HTTP常见请求头？" class="headerlink" title="126.HTTP常见请求头？"></a>126.HTTP常见请求头？</h4><p>HTTP消息头是在，客户端请求（Request）或服务器响应（Response）时传递的，位请求或响应的第一行，HTTP消息体（请求或响应的内容）是其后传输。HTTP消息头，以明文的字符串格式传送，是以冒号分隔的键/值对，如：Accept-Charset: utf-8，每一个消息头最后以回车符(CR)和换行符(LF)结尾。HTTP消息头结束后，会用一个空白的字段来标识，这样就会出现两个连续的CR-LF。</p>
<p>HTTP消息头由IANA（The Internet Assigned Numbers Authority，互联网数字分配机构）来整理和维护。其标准最早来源于RFC 4229。IANA将其整理到了消息头文档，文档中还包括了一些新提出的信息头。</p>
<p>HTTP消息头支持自定义， 自定义的专用消息头一般会添加’X-‘前缀。</p>
<p>常用的HTTP请求头:</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">Accept    可接受的响应内容类型（Content-Types）。    Accept: text/plain</span><br><span class="line">Authorization    用于表示HTTP协议中需要认证资源的认证信息    Authorization: Basic OSdjJGRpbjpvcGVuIANlc2SdDE==</span><br><span class="line">Cache-Control    用来指定当前的请求/回复中的，是否使用缓存机制。    Cache-Control: no-cache</span><br><span class="line">Cookie    由之前服务器通过Set-Cookie（见下文）设置的一个HTTP协议Cookie    Cookie: $Version=<span class="number">1</span>; Skin=new;</span><br><span class="line">Referer    表示浏览器所访问的前一个页面，可以认为是之前访问页面的链接将浏览器带到了当前页面。Referer其实是Referrer这个单词，但RFC制作标准时给拼错了，后来也就将错就错使用Referer了。    Referer: http://itbilu.com/nodejs</span><br><span class="line">User-Agent    浏览器的身份标识字符串    User-Agent: Mozilla/……</span><br></pre></td></tr></table></figure>

<p>常用的HTTP响应头</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">Status    通用网关接口的响应头字段，用来说明当前HTTP连接的响应状态。    Status: <span class="number">200</span> OK</span><br><span class="line">Set-Cookie    设置HTTP cookie    Set-Cookie: UserID=itbilu; Max-Age=<span class="number">3600</span>; Version=<span class="number">1</span></span><br><span class="line">Server    服务器的名称    Server: nginx/<span class="number">1.6</span><span class="number">.3</span></span><br><span class="line">Expires    指定一个日期/时间，超过该时间则认为此回应已经过期    Expires: Thu, <span class="number">01</span> Dec <span class="number">1994</span> <span class="number">16</span>:<span class="number">00</span>:<span class="number">00</span> GMT</span><br></pre></td></tr></table></figure>

<h4 id="127-七层模型？"><a href="#127-七层模型？" class="headerlink" title="127.七层模型？"></a>127.七层模型？</h4><p><img src="C:/Users/%E9%80%B8%E5%8F%AF/Desktop/.gitbook/assets/web-7.jpg" alt="&#x4E03;&#x5C42;"></p>
<h4 id="128-url的形式？"><a href="#128-url的形式？" class="headerlink" title="128.url的形式？"></a>128.url的形式？</h4><h2 id="Web"><a href="#Web" class="headerlink" title="Web"></a>Web</h2><h3 id="Flask"><a href="#Flask" class="headerlink" title="Flask"></a>Flask</h3><h4 id="129-对Flask蓝图-Blueprint-的理解？"><a href="#129-对Flask蓝图-Blueprint-的理解？" class="headerlink" title="129.对Flask蓝图(Blueprint)的理解？"></a>129.对Flask蓝图(Blueprint)的理解？</h4><p>蓝图的定义</p>
<p>蓝图 /Blueprint 是Flask应用程序组件化的方法，可以在一个应用内或跨越多个项目共用蓝图。使用蓝图可以极大简化大型应用的开发难度，也为Flask扩展提供了一种在应用中注册服务的集中式机制。</p>
<p>蓝图的应用场景：</p>
<p>把一个应用分解为一个蓝图的集合。这对大型应用是理想的。一个项目可以实例化一个应用对象，初始化几个扩展，并注册一集合的蓝图。</p>
<p>以URL前缀和/或子域名，在应用上注册一个蓝图。URL前缀/子域名中的参数即成为这个蓝图下的所有视图函数的共同的视图参数（默认情况下） 在一个应用中用不同的URL规则多次注册一个蓝图。</p>
<p>通过蓝图提供模板过滤器、静态文件、模板和其他功能。一个蓝图不一定要实现应用或视图函数。</p>
<p>初始化一个Flask扩展时，在这些情况中注册一个蓝图。</p>
<p>蓝图的缺点：</p>
<p>不能在应用创建后撤销注册一个蓝图而不销毁整个应用对象。</p>
<p>使用蓝图的三个步骤</p>
<p>1.创建一个蓝图对象</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">blue = Blueprint(<span class="string">&quot;blue&quot;</span>,__name__)</span><br></pre></td></tr></table></figure>

<p>2.在这个蓝图对象上进行操作，例如注册路由、指定静态文件夹、注册模板过滤器…</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">@blue.route(&#x27;/&#x27;)</span></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">blue_index</span>():</span></span><br><span class="line">    <span class="keyword">return</span> <span class="string">&quot;Welcome to my blueprint&quot;</span></span><br></pre></td></tr></table></figure>

<p>3.在应用对象上注册这个蓝图对象</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">app.register_blueprint(blue,url_prefix=<span class="string">&quot;/blue&quot;</span>)</span><br></pre></td></tr></table></figure>

<h4 id="130-Flask-和-Django-路由映射的区别？"><a href="#130-Flask-和-Django-路由映射的区别？" class="headerlink" title="130.Flask 和 Django 路由映射的区别？"></a>130.Flask 和 Django 路由映射的区别？</h4><p>在django中，路由是浏览器访问服务器时，先访问的项目中的url，再由项目中的url找到应用中url，这些url是放在一个列表里，遵从从前往后匹配的规则。在flask中，路由是通过装饰器给每个视图函数提供的，而且根据请求方式的不同可以一个url用于不同的作用。</p>
<h3 id="Django"><a href="#Django" class="headerlink" title="Django"></a>Django</h3><h4 id="131-ORM是什么，ORM的优缺点"><a href="#131-ORM是什么，ORM的优缺点" class="headerlink" title="131.ORM是什么，ORM的优缺点"></a>131.ORM是什么，ORM的优缺点</h4><p>ORM的全称是：Object Relational Mapping （对象 关系 映射）</p>
<p>简单的说，orm是通过使用描述对象和数据之间映射的元数据，将程序中的对象自动持久化到关系数据库中。</p>
<p>ORM需要解决的问题是，能否把对象的数据直接保存到数据库中，又能否直接从数据库中拿到一个对象？要想做到上面两点，则必须要有映射关系。</p>
<p>ORM的优缺点</p>
<p>优点：</p>
<p>orm的技术特点，提高了开发效率。可以自动对实体Entity对象与数据库中的Table进行字段与属性的映射；不用直接SQL编码，能够像操作对象一样从数据库中获取数据</p>
<p>缺点：</p>
<p>orm会牺牲程序的执行效率和会固定思维模式，在从系统结构上来看，采用orm的系统多是多层系统的，系统的层次太多，效率就会降低，orm是一种完全面向对象的做法，所以面向对象的做法也会对性能产生一定的影响。</p>
<h4 id="132-查找-Django-项目中的性能瓶颈"><a href="#132-查找-Django-项目中的性能瓶颈" class="headerlink" title="132.查找 Django 项目中的性能瓶颈"></a>132.查找 Django 项目中的性能瓶颈</h4><p>django-debug-toolbar or Django-silk</p>
<p>该工具能检测出查询操作都来自何处。从而能检测出到以下瓶颈： 页面中的重复查询 ORM 调用引起的查询操作次数比预想的多 查询很慢</p>
<p>针对查询操作较多的页面进行优化提速 推荐看 Django 官方的<a target="_blank" rel="noopener" href="https://docs.djangoproject.com/en/dev/topics/db/optimization/">数据库优化文档</a></p>
<p>使用 Memcached 或 Redis 对查询进行缓存</p>
<p>压缩 HTML、CSS 和 JavaScript</p>
<h4 id="133-什么是wsgi-uwsgi-uWSGI"><a href="#133-什么是wsgi-uwsgi-uWSGI" class="headerlink" title="133.什么是wsgi,uwsgi,uWSGI?"></a>133.什么是wsgi,uwsgi,uWSGI?</h4><p>WSGI:</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">web服务器网关接口，是一套协议。用于接收用户请求并将请求进行初次封装，然后将请求交给web框架。</span><br></pre></td></tr></table></figure>

<p>实现wsgi协议的模块：</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">wsgiref,本质上就是编写一socket服务端，用于接收用户请求（django)</span><br><span class="line"></span><br><span class="line">werkzeug,本质上就是编写一个socket服务端，用于接收用户请求(flask)</span><br></pre></td></tr></table></figure>

<p>uwsgi:</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">与WSGI一样是一种通信协议，它是uWSGI服务器的独占协议，用于定义传输信息的类型。</span><br><span class="line">uWSGI:</span><br><span class="line"></span><br><span class="line">是一个web服务器，实现了WSGI的协议，uWSGI协议，http协议</span><br></pre></td></tr></table></figure>

<h4 id="134-Django、Flask、Tornado的对比？"><a href="#134-Django、Flask、Tornado的对比？" class="headerlink" title="134.Django、Flask、Tornado的对比？"></a>134.Django、Flask、Tornado的对比？</h4><p>1、 Django</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line">走的大而全的方向，开发效率高。它的MTV框架，自带的ORM,admin后台管理,自带的sqlite数据库和开发测试用的服务器，给开发者提高了超高的开发效率。</span><br><span class="line">重量级web框架，功能齐全，提供一站式解决的思路，能让开发者不用在选择上花费大量时间。</span><br><span class="line"></span><br><span class="line">自带ORM和模板引擎，支持jinja等非官方模板引擎。</span><br><span class="line"></span><br><span class="line">自带ORM使Django和关系型数据库耦合度高，如果要使用非关系型数据库，需要使用第三方库</span><br><span class="line"></span><br><span class="line">自带数据库管理app</span><br><span class="line"></span><br><span class="line">成熟，稳定，开发效率高，相对于Flask，Django的整体封闭性比较好，适合做企业级网站的开发。python web框架的先驱，第三方库丰富</span><br></pre></td></tr></table></figure>

<p>2、 Flask</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">是轻量级的框架，自由，灵活，可扩展性强，核心基于Werkzeug WSGI工具 和jinja2 模板引擎</span><br><span class="line"></span><br><span class="line">适用于做小网站以及web服务的API,开发大型网站无压力，但架构需要自己设计</span><br><span class="line"></span><br><span class="line">与关系型数据库的结合不弱于Django，而与非关系型数据库的结合远远优于Django</span><br></pre></td></tr></table></figure>

<p>3、 Tornado</p>
<figure class="highlight text"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">走的是少而精的方向，性能优越，它最出名的异步非阻塞的设计方式</span><br><span class="line"></span><br><span class="line">Tornado的两大核心模块：</span><br><span class="line"></span><br><span class="line">iostraem:对非阻塞的socket进行简单的封装</span><br><span class="line"></span><br><span class="line">ioloop: 对I/O 多路复用的封装,它实现一个单例</span><br></pre></td></tr></table></figure>

<h4 id="135-CORS-和-CSRF的区别？"><a href="#135-CORS-和-CSRF的区别？" class="headerlink" title="135.CORS 和 CSRF的区别？"></a>135.CORS 和 CSRF的区别？</h4><p>什么是CORS？</p>
<p>CORS是一个W3C标准,全称是“跨域资源共享”(Cross-origin resoure sharing). 它允许浏览器向跨源服务器，发出XMLHttpRequest请求，从而客服了AJAX只能同源使用的限制。</p>
<p>什么是CSRF？</p>
<p>CSRF主流防御方式是在后端生成表单的时候生成一串随机token,内置到表单里成为一个字段，同时，将此串token置入session中。每次表单提交到后端时都会检查这两个值是否一致，以此来判断此次表单提交是否是可信的，提交过一次之后，如果这个页面没有生成CSRF token,那么token将会被清空,如果有新的需求，那么token会被更新。 攻击者可以伪造POST表单提交，但是他没有后端生成的内置于表单的token，session中没有token都无济于事。</p>
<h4 id="136-Session-Cookie-JWT的理解"><a href="#136-Session-Cookie-JWT的理解" class="headerlink" title="136.Session,Cookie,JWT的理解"></a>136.Session,Cookie,JWT的理解</h4><p>为什么要使用会话管理</p>
<p>众所周知，HTTP协议是一个无状态的协议，也就是说每个请求都是一个独立的请求，请求与请求之间并无关系。但在实际的应用场景，这种方式并不能满足我们的需求。举个大家都喜欢用的例子，把商品加入购物车，单独考虑这个请求，服务端并不知道这个商品是谁的，应该加入谁的购物车？因此这个请求的上下文环境实际上应该包含用户的相关信息，在每次用户发出请求时把这一小部分额外信息，也做为请求的一部分，这样服务端就可以根据上下文中的信息，针对具体的用户进行操作。所以这几种技术的出现都是对HTTP协议的一个补充，使得我们可以用HTTP协议+状态管理构建一个的面向用户的WEB应用。</p>
<p>Session 和Cookie的区别</p>
<p>这里我想先谈谈session与cookies,因为这两个技术是做为开发最为常见的。那么session与cookies的区别是什么？个人认为session与cookies最核心区别在于额外信息由谁来维护。利用cookies来实现会话管理时，用户的相关信息或者其他我们想要保持在每个请求中的信息，都是放在cookies中,而cookies是由客户端来保存，每当客户端发出新请求时，就会稍带上cookies,服务端会根据其中的信息进行操作。 当利用session来进行会话管理时，客户端实际上只存了一个由服务端发送的session_id,而由这个session_id,可以在服务端还原出所需要的所有状态信息，从这里可以看出这部分信息是由服务端来维护的。</p>
<p>除此以外，session与cookies都有一些自己的缺点：</p>
<p>cookies的安全性不好，攻击者可以通过获取本地cookies进行欺骗或者利用cookies进行CSRF攻击。使用cookies时,在多个域名下，会存在跨域问题。 session 在一定的时间里，需要存放在服务端，因此当拥有大量用户时，也会大幅度降低服务端的性能，当有多台机器时，如何共享session也会是一个问题.(redis集群)也就是说，用户第一个访问的时候是服务器A，而第二个请求被转发给了服务器B，那服务器B如何得知其状态。实际上，session与cookies是有联系的，比如我们可以把session_id存放在cookies中的。</p>
<p>JWT是如何工作的</p>
<p>首先用户发出登录请求，服务端根据用户的登录请求进行匹配，如果匹配成功，将相关的信息放入payload中，利用算法，加上服务端的密钥生成token，这里需要注意的是secret_key很重要，如果这个泄露的话，客户端就可以随机篡改发送的额外信息，它是信息完整性的保证。生成token后服务端将其返回给客户端，客户端可以在下次请求时，将token一起交给服务端，一般是说我们可以将其放在Authorization首部中，这样也就可以避免跨域问题。</p>
<h4 id="137-简述Django请求生命周期"><a href="#137-简述Django请求生命周期" class="headerlink" title="137.简述Django请求生命周期"></a>137.简述Django请求生命周期</h4><p>一般是用户通过浏览器向我们的服务器发起一个请求(request),这个请求会去访问视图函数，如果不涉及到数据调用，那么这个时候视图函数返回一个模板也就是一个网页给用户） 视图函数调用模型毛模型去数据库查找数据，然后逐级返回，视图函数把返回的数据填充到模板中空格中，最后返回网页给用户。</p>
<p>1.wsgi ,请求封装后交给web框架（Flask，Django)</p>
<p>2.中间件，对请求进行校验或在请求对象中添加其他相关数据，例如：csrf,request.session</p>
<p>3.路由匹配 根据浏览器发送的不同url去匹配不同的视图函数</p>
<p>4.视图函数，在视图函数中进行业务逻辑的处理，可能涉及到：orm，templates</p>
<p>5.中间件，对响应的数据进行处理</p>
<p>6.wsgi，将响应的内容发送给浏览器</p>
<h4 id="138-用的restframework完成api发送时间时区"><a href="#138-用的restframework完成api发送时间时区" class="headerlink" title="138.用的restframework完成api发送时间时区"></a>138.用的restframework完成api发送时间时区</h4><p>当前的问题是用django的rest framework模块做一个get请求的发送时间以及时区信息的api</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">getCurrenttime</span>(<span class="params">APIView</span>):</span></span><br><span class="line">    <span class="function"><span class="keyword">def</span> <span class="title">get</span>(<span class="params">self,request</span>):</span></span><br><span class="line">        local_time = time.localtime()</span><br><span class="line">        time_zone =settings.TIME_ZONE</span><br><span class="line">        temp = &#123;<span class="string">&#x27;localtime&#x27;</span>:local_time,<span class="string">&#x27;timezone&#x27;</span>:time_zone&#125;</span><br><span class="line">        <span class="keyword">return</span> Response(temp)</span><br></pre></td></tr></table></figure>

<h4 id="139-nginx-tomcat-apach到都是什么？"><a href="#139-nginx-tomcat-apach到都是什么？" class="headerlink" title="139.nginx,tomcat,apach到都是什么？"></a>139.nginx,tomcat,apach到都是什么？</h4><p>Nginx（engine x)是一个高性能的HTTP和反向代理服务器，也是 一个IMAP/POP3/SMTP服务器，工作在OSI七层，负载的实现方式：轮询，IP_HASH,fair,session_sticky.</p>
<p>Apache HTTP Server是一个模块化的服务器，源于NCSAhttpd服务器</p>
<p>Tomcat 服务器是一个免费的开放源代码的Web应用服务器，属于轻量级应用服务器，是开发和调试JSP程序的首选。</p>
<h4 id="140-请给出你熟悉关系数据库范式有哪些，有什么作用？"><a href="#140-请给出你熟悉关系数据库范式有哪些，有什么作用？" class="headerlink" title="140.请给出你熟悉关系数据库范式有哪些，有什么作用？"></a>140.请给出你熟悉关系数据库范式有哪些，有什么作用？</h4><p>在进行数据库的设计时，所遵循的一些规范，只要按照设计规范进行设计，就能设计出没有数据冗余和数据维护异常的数据库结构。</p>
<p>数据库的设计的规范有很多，通常来说我们在设是数据库时只要达到其中一些规范就可以了，这些规范又称之为数据库的三范式，一共有三条，也存在着其他范式，我们只要做到满足前三个范式的要求，就能设陈出符合我们的数据库了，我们也不能全部来按照范式的要求来做，还要考虑实际的业务使用情况，所以有时候也需要做一些违反范式的要求。</p>
<p>1.数据库设计的第一范式(最基本)，基本上所有数据库的范式都是符合第一范式的，符合第一范式的表具有以下几个特点：</p>
<p>数据库表中的所有字段都只具有单一属性，单一属性的列是由基本的数据类型（整型，浮点型，字符型等）所构成的设计出来的表都是简单的二比表</p>
<p>2.数据库设计的第二范式(是在第一范式的基础上设计的)，要求一个表中只具有一个业务主键，也就是说符合第二范式的表中不能存在非主键列对只对部分主键的依赖关系</p>
<p>3.数据库设计的第三范式，指每一个非主属性既不部分依赖与也不传递依赖于业务主键，也就是第二范式的基础上消除了非主属性对主键的传递依赖</p>
<h4 id="141-简述QQ登陆过程"><a href="#141-简述QQ登陆过程" class="headerlink" title="141.简述QQ登陆过程"></a>141.简述QQ登陆过程</h4><p>qq登录，在我们的项目中分为了三个接口，</p>
<p>第一个接口是请求qq服务器返回一个qq登录的界面;</p>
<p>第二个接口是通过扫码或账号登陆进行验证，qq服务器返回给浏览器一个code和state,利用这个code通过本地服务器去向qq服务器获取access_token覆返回给本地服务器，凭借access_token再向qq服务器获取用户的openid(openid用户的唯一标识)</p>
<p>第三个接口是判断用户是否是第一次qq登录，如果不是的话直接登录返回的jwt-token给用户，对没有绑定过本网站的用户，对openid进行加密生成token进行绑定</p>
<h4 id="142-项目中日志的作用"><a href="#142-项目中日志的作用" class="headerlink" title="142.项目中日志的作用"></a>142.项目中日志的作用</h4><p>一、日志相关概念</p>
<p>1.日志是一种可以追踪某些软件运行时所发生事件的方法</p>
<p>2.软件开发人员可以向他们的代码中调用日志记录相关的方法来表明发生了某些事情</p>
<p>3.一个事件可以用一个包含可选变量数据的消息来描述</p>
<p>4.此外，事件也有重要性的概念，这个重要性也可以被成为严重性级别(level)</p>
<p>二、日志的作用</p>
<p>1.通过log的分析，可以方便用户了解系统或软件、应用的运行情况;</p>
<p>2.如果你的应用log足够丰富，可以分析以往用户的操作行为、类型喜好，地域分布或其他更多信息;</p>
<p>3.如果一个应用的log同时也分了多个级别，那么可以很轻易地分析得到该应用的健康状况，及时发现问题并快速定位、解决问题，补救损失。</p>
<p>4.简单来讲就是我们通过记录和分析日志可以了解一个系统或软件程序运行情况是否正常，也可以在应用程序出现故障时快速定位问题。不仅在开发中，在运维中日志也很重要，日志的作用也可以简单。总结为以下几点：</p>
<p>1.程序调试</p>
<p>2.了解软件程序运行情况，是否正常</p>
<p>3,软件程序运行故障分析与问题定位</p>
<p>4,如果应用的日志信息足够详细和丰富，还可以用来做用户行为分析</p>
<h4 id="143-django中间件的使用？"><a href="#143-django中间件的使用？" class="headerlink" title="143.django中间件的使用？"></a>143.django中间件的使用？</h4><p>Django在中间件中预置了六个方法，这六个方法的区别在于不同的阶段执行，对输入或输出进行干预，方法如下：</p>
<p>1.初始化：无需任何参数，服务器响应第一个请求的时候调用一次，用于确定是否启用当前中间件</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">__init__</span>():</span></span><br><span class="line">    <span class="keyword">pass</span></span><br></pre></td></tr></table></figure>

<p>2.处理请求前：在每个请求上调用，返回None或HttpResponse对象。</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">process_request</span>(<span class="params">request</span>):</span></span><br><span class="line">    <span class="keyword">pass</span></span><br></pre></td></tr></table></figure>

<p>3.处理视图前:在每个请求上调用，返回None或HttpResponse对象。</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">process_view</span>(<span class="params">request,view_func,view_args,view_kwargs</span>):</span></span><br><span class="line">    <span class="keyword">pass</span></span><br></pre></td></tr></table></figure>

<p>4.处理模板响应前：在每个请求上调用，返回实现了render方法的响应对象。</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">process_template_response</span>(<span class="params">request,response</span>):</span></span><br><span class="line">    <span class="keyword">pass</span></span><br></pre></td></tr></table></figure>

<p>5.处理响应后：所有响应返回浏览器之前被调用，在每个请求上调用，返回HttpResponse对象。</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">process_response</span>(<span class="params">request,response</span>):</span></span><br><span class="line">    <span class="keyword">pass</span></span><br></pre></td></tr></table></figure>

<p>6.异常处理：当视图抛出异常时调用，在每个请求上调用，返回一个HttpResponse对象。</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">process_exception</span>(<span class="params">request,exception</span>):</span></span><br><span class="line">    <span class="keyword">pass</span></span><br></pre></td></tr></table></figure>

<h4 id="144-谈一下你对uWSGI和nginx的理解？"><a href="#144-谈一下你对uWSGI和nginx的理解？" class="headerlink" title="144.谈一下你对uWSGI和nginx的理解？"></a>144.谈一下你对uWSGI和nginx的理解？</h4><p>1.uWSGI是一个Web服务器，它实现了WSGI协议、uwsgi、http等协议。Nginx中HttpUwsgiModule的作用是与uWSGI服务器进行交换。WSGI是一种Web服务器网关接口。它是一个Web服务器（如nginx，uWSGI等服务器）与web应用（如用Flask框架写的程序）通信的一种规范。</p>
<p>要注意WSGI/uwsgi/uWSGI这三个概念的区分。</p>
<p>WSGI是一种通信协议。</p>
<p>uwsgi是一种线路协议而不是通信协议，在此常用于在uWSGI服务器与其他网络服务器的数据通信。</p>
<p>uWSGI是实现了uwsgi和WSGI两种协议的Web服务器。</p>
<p>nginx 是一个开源的高性能的HTTP服务器和反向代理：</p>
<p>1.作为web服务器，它处理静态文件和索引文件效果非常高</p>
<p>2.它的设计非常注重效率，最大支持5万个并发连接，但只占用很少的内存空间</p>
<p>3.稳定性高，配置简洁。</p>
<p>4.强大的反向代理和负载均衡功能，平衡集群中各个服务器的负载压力应用</p>
<h4 id="145-Python中三大框架各自的应用场景？"><a href="#145-Python中三大框架各自的应用场景？" class="headerlink" title="145.Python中三大框架各自的应用场景？"></a>145.Python中三大框架各自的应用场景？</h4><p>django:主要是用来搞快速开发的，他的亮点就是快速开发，节约成本，,如果要实现高并发的话，就要对django进行二次开发，比如把整个笨重的框架给拆掉自己写socket实现http的通信,底层用纯c,c++写提升效率，ORM框架给干掉，自己编写封装与数据库交互的框架,ORM虽然面向对象来操作数据库，但是它的效率很低，使用外键来联系表与表之间的查询; flask: 轻量级，主要是用来写接口的一个框架，实现前后端分离，提高开发效率，Flask本身相当于一个内核，其他几乎所有的功能都要用到扩展(邮件扩展Flask-Mail，用户认证Flask-Login),都需要用第三方的扩展来实现。比如可以用Flask-extension加入ORM、文件上传、身份验证等。Flask没有默认使用的数据库，你可以选择MySQL，也可以用NoSQL。</p>
<p>其WSGI工具箱用Werkzeug(路由模块)，模板引擎则使用Jinja2,这两个也是Flask框架的核心。</p>
<p>Tornado： Tornado是一种Web服务器软件的开源版本。Tornado和现在的主流Web服务器框架（包括大多数Python的框架）有着明显的区别：它是非阻塞式服务器，而且速度相当快。得利于其非阻塞的方式和对epoll的运用，Tornado每秒可以处理数以千计的连接因此Tornado是实时Web服务的一个理想框架</p>
<h4 id="146-Django中哪里用到了线程？哪里用到了协程？哪里用到了进程？"><a href="#146-Django中哪里用到了线程？哪里用到了协程？哪里用到了进程？" class="headerlink" title="146.Django中哪里用到了线程？哪里用到了协程？哪里用到了进程？"></a>146.Django中哪里用到了线程？哪里用到了协程？哪里用到了进程？</h4><p>1.Django中耗时的任务用一个进程或者线程来执行，比如发邮件，使用celery.</p>
<p>2.部署django项目是时候，配置文件中设置了进程和协程的相关配置。</p>
<h4 id="147-有用过Django-REST-framework吗？"><a href="#147-有用过Django-REST-framework吗？" class="headerlink" title="147.有用过Django REST framework吗？"></a>147.有用过Django REST framework吗？</h4><p>Django REST framework是一个强大而灵活的Web API工具。使用RESTframework的理由有：</p>
<p>Web browsable API对开发者有极大的好处</p>
<p>包括OAuth1a和OAuth2的认证策略</p>
<p>支持ORM和非ORM数据资源的序列化</p>
<p>全程自定义开发–如果不想使用更加强大的功能，可仅仅使用常规的function-based views额外的文档和强大的社区支持</p>
<h4 id="148-对cookies与session的了解？他们能单独用吗？"><a href="#148-对cookies与session的了解？他们能单独用吗？" class="headerlink" title="148.对cookies与session的了解？他们能单独用吗？"></a>148.对cookies与session的了解？他们能单独用吗？</h4><p>Session采用的是在服务器端保持状态的方案，而Cookie采用的是在客户端保持状态的方案。但是禁用Cookie就不能得到Session。因为Session是用Session ID来确定当前对话所对应的服务器Session，而Session ID是通过Cookie来传递的，禁用Cookie相当于SessionID,也就得不到Session。</p>
<h4 id="149-测试工具"><a href="#149-测试工具" class="headerlink" title="149.测试工具"></a>149.测试工具</h4><p>unittest:一个通用的测试框架</p>
<p>doctest:一个更简单的模块，是为检查文档而设计的，同时非常适合用来编写单元测试。</p>
<p>locust: 性能测试工具</p>
<p>mock: (Python3 标准库) mock和patch。</p>
<p>factoryboy, Python测试fixtures(setup和teardown)替代库。 faker 生成多种伪数据。</p>
<h2 id="1-python内存管理"><a href="#1-python内存管理" class="headerlink" title="1.python内存管理"></a>1.python内存管理</h2><p>python有一个私有堆空间来保存所有的对象和数据结构，我们无法访问它，是解释器在管理。</p>
<p><strong>对象存储</strong></p>
<p>首先，在python中，万物皆对象，每个对象第一次被创建时都会在内存中开辟一块空间来存储。</p>
<p><strong>引用计数</strong></p>
<p>每创建一个对象，对应的引用为1。如果这个对象被赋值或引用时，对应的引用计数+1，如果被销毁，引用计数-1。若该对象的引用计数为0时，对象会自动销毁。</p>
<p><strong>循环引用</strong>.</p>
<figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">a_list = []</span><br><span class="line">b_list = []</span><br><span class="line">a_list.append(b_list)</span><br><span class="line">b_list.append(a_list)</span><br></pre></td></tr></table></figure>

<p>a_list与b_list相互引用，如果不存在其他对象对他们的引用。a_list与b_list的引用计数也仍然为1，所占用的内存永远无法被回收，这将是致命的。</p>
<p><strong>标记-清除</strong></p>
<p>标记清除机制其实就是为了解决循环引用问题的，首先遍历所有对象，如果对象除了循环引用外还有别的引用，说明其有效，就标记为可达，如果不可达，则对其进行清除</p>
<p><strong>分代回收</strong></p>
<p>这种机制是典型的以空间换时间的技术。当对象被创建时标记为第0代，经过一次垃圾回收之后，余下的对象被标记为第1代，最高为第2代。0代触发将清理所有三代，1代触发会清理1,2代，2代触发后只会清理自己。</p>
<p>这种思想简单点说就是：对象存在时间越长，越可能不是垃圾，应该越少去收集。</p>
<p><strong>对象缓存</strong></p>
<p>类型值的内置数据类型，数字、字符串、列表、字典等都会有自己的对象缓存池，这样做的好处是，避免了频繁的申请内存，释放内存，这样会极大的降低应用程序的运行速度，还会造成大量的碎片。因此提供对象缓存机制是非常必要的。</p>
<p><strong>多次赋值</strong></p>
<p>对于整数和短小的字符，python会进行缓存，不会创建多个相同对象</p>
<p>此时，被多次赋值，只会有多份引用</p>
<p><strong>内存地址</strong></p>
<p>可以通过id()来查看</p>
<p>a is b 判断 a 对象是否就是 b 对象（通过id来判断）</p>
<p>a == b 判断 a 对象的值是否和 b 对象的值相等（通过value来判断）</p>
<p><strong>内存占用</strong></p>
<p>sys.getsizeof(a)</p>
<p><strong>查看引用计数</strong></p>
<p>sys.getrefcount(a)</p>
<p><strong>解释器</strong></p>
<p>python是一门解释器语言，代码想运行，必须通过解释器执行，python存在多种解释器，分别基于不同语言开发，每个解释器都有不同的特点</p>
<ol>
<li><p>CPython</p>
<p>python的默认解释器，是C语言开发的，所以叫CPython。也是使用最广的</p>
</li>
<li><p>IPython</p>
<p>是基于cpython之上的一个交互式解释器，只是在交互方式上有所增强</p>
</li>
<li><p>PyPy</p>
<p>它的目标是执行速度。对python代码进行动态编译，所以显著提高python代码的执行速度。</p>
</li>
</ol>
<p><strong>GIL全局解释器锁</strong></p>
<p>保证同一时刻只有一个线程对资源有操作权限（使用CPU），相当于是单线程在执行，它也是Cpython解释器的特性，所以python也被人诟病说是伪多线程</p>
<p><strong>如何避免</strong></p>
<p>可以使用多进程或者协程，或者换解释器，例如PyPy</p>
<h2 id="数据类型"><a href="#数据类型" class="headerlink" title="数据类型"></a>数据类型</h2><p>数字（Numbers）</p>
<p>字符串（String）</p>
<p>列表（List）</p>
<p>元组（Tuple）</p>
<p>字典（Dictionary）</p>
<p>集合（Set）</p>
<p>不可变集合（frozenset）：集合是无序，可变的。而不可变集合却不可变，这意味着我们无法改变它的值，从而也使其无法作为字典的键值。</p>
<h3 id="常用内置方法"><a href="#常用内置方法" class="headerlink" title="常用内置方法"></a><strong>常用内置方法</strong></h3><h4 id="List"><a href="#List" class="headerlink" title="List"></a><strong>List</strong></h4><p>append()：末尾添加元素</p>
<p>extend()：一次性在列表的末尾添加一个序列：比如有一个字符串<code>string</code>，list1.append(‘string’)会将字符串中的每一个字符逐一添加到列表的末尾，当然这个序列也可以是列表，元组</p>
<p>insert(索引，value)：指定索引位置插入元素</p>
<p>pop(index)：删除元素，并且返回被删除的value，不写参数默认删除末尾，可以指定索引删除</p>
<p>remove(value)：删除列表中的某个值，如果有多个只会删除第一个</p>
<p>count(value)：统计列表中value存在的个数</p>
<p>index(value)：查找value所在的索引位置，如果不存在会抛出ValueError异常</p>
<p>sort(reverse=True)：对列表进行排序，指定参数reverse=True会倒序，若是字符串排序，会按照字符的ascii来排序</p>
<p>reverse()：倒序</p>
<h4 id="String"><a href="#String" class="headerlink" title="String"></a><strong>String</strong></h4><p><strong>查找</strong></p>
<p>find(value)：在字符串中查找子串，如果不存在，返回-1</p>
<p>index(value)：同上，如果不存在会抛出ValueError异常</p>
<p>count(value)：统计字符出现次数</p>
<p><strong>操作</strong></p>
<p>replace(oldvalue, newvalue, count)：替换，第一个参数代表原来字符，第二个参数代表新字符  第三个参数 代表替换个数</p>
<p>split(value)：将字符串进行分割，分割的结果会变为一个列表</p>
<p>join()：按照指定字符拼接字符串</p>
<p><strong>判断</strong></p>
<p>startswith(value)：  判断字符串以什么开头  返回结果是 True 或  False</p>
<p>endwith(value)：  以什么结尾   跟startswith对应</p>
<p>isalpha()：检测所有字符是否为字母</p>
<p>isdigit()：检测是否都为数字</p>
<p>isalnum()： 检测所有字符都是字母或数字返回 True,否则返回False</p>
<p><strong>大小写转换</strong></p>
<p>upper()  转换为大写·</p>
<p>lower()  转换为小写</p>
<p>title()  每个单词的首字母变大写</p>
<p><strong>去空白字符</strong></p>
<p>lstrip() 删除左边的空白字符</p>
<p>rstrip() 删除字符串末尾的空白字符</p>
<p>strip() 删除字符串两端的空白字符</p>
<p><strong>ASCII转换</strong></p>
<p>ASCII转换字符：chr()</p>
<p>字符转换ASCII：ord()</p>
<h4 id="dict"><a href="#dict" class="headerlink" title="dict"></a><strong>dict</strong></h4><p>clear()：清空字典的所有项</p>
<p>get(key, value(若key不存在可以指定返回的value))：通过key获取对应的value，如果不存在返回None，也可以指定返回的value</p>
<p>fromkeys()：使用给定的key建立一个新的字典，每个key都对应一个默认value：None</p>
<p>keys()：获取字典中所有的key</p>
<p>value()：获取字典中所有的value</p>
<p>items()：每个键值以元组的方式存入列表，返回结果</p>
<p>pop(key)：通过传入的key删除对应的键值对，并且将这个键值对返回</p>
<p>update()：用法：a.update(b)，a和b都是字典，利用一个字典更新另一个字典，如果有相同的key则会被覆盖</p>
<p>zip()：可以将两个列表组合成字典</p>
<h4 id="set"><a href="#set" class="headerlink" title="set"></a><strong>set</strong></h4><p>add()</p>
<p>clear()</p>
<p>pop()</p>
<p>remove()</p>
<p>交集：set1.intersection(set2)：在set1和set2中都有的元素</p>
<p>并集：set1.union(set2)，获取两个集合中的全部元素，重复元素只获取一个</p>
<p>差集：set1.difference(set2)，在set1中有，set2中没有</p>
<h4 id="tuple"><a href="#tuple" class="headerlink" title="tuple"></a><strong>tuple</strong></h4><p>count()</p>
<p>index()</p>
<h4 id="list和tuple区别："><a href="#list和tuple区别：" class="headerlink" title="list和tuple区别："></a><strong>list和tuple区别：</strong></h4><p>相同点：都是按顺序保存元素，都可以用索引来访问元素</p>
<p>最本质的区别，list是可变，tuple是不可变的</p>
<p>元组用于存储异构数据，也就是具有不同意义的数据，例如记录一个人的身高，体重，年龄。列表一般用来存储同构数据，就是具有相同意义的数据</p>
<p>由于元组支持的操作比列表小，所以性能会更好一点</p>
<h4 id="list和dict区别："><a href="#list和dict区别：" class="headerlink" title="list和dict区别："></a>list和dict区别：</h4><ol>
<li>list是有序的，dict是无序的</li>
<li>list通过索引访问，dict使用key访问</li>
<li>dict的占用内存稍比list大，会在1.5倍左右</li>
<li>列表是序列，可以理解为数据结构中的数组，字典可以理解为数据结构中的hashmap</li>
</ol>
<h4 id="python2和python3区别"><a href="#python2和python3区别" class="headerlink" title="python2和python3区别"></a><strong>python2和python3区别</strong></h4><p>print语句变为了函数</p>
<p>python2的默认编码是ascii，需要更改字符集才能正常支持中文，所以在.py文件中会看到#– coding: UTF-8 –</p>
<p>除法运算：python2是整数，python3结果是浮点</p>
<p>不等运算符：去掉了&lt;&gt;</p>
<p>去掉了long类型</p>
<h4 id="可变、不可变"><a href="#可变、不可变" class="headerlink" title="可变、不可变"></a>可变、不可变</h4><p>可变类型：list、dict、set</p>
<p>不可变类型：数字、string、tuple</p>
<p>可变和不可变是指内存中的value是否可以被改变，操作不可变对象时，会申请一块新空间用来存储。而可变类型在改变时内存地址保持不变，区域会变长或者变短。</p>
<h4 id="深浅拷贝"><a href="#深浅拷贝" class="headerlink" title="深浅拷贝"></a>深浅拷贝</h4><p>浅拷贝：只拷贝顶层数据，其余层拷贝的是引用，切片也是浅拷贝</p>
<p>深拷贝：是递归性质的拷贝，会在内存中生成一套完全一样的内容。改变时互不影响</p>
<p>例子：克隆羊与化名</p>
<h4 id="浅拷贝三种情况"><a href="#浅拷贝三种情况" class="headerlink" title="浅拷贝三种情况"></a>浅拷贝三种情况</h4><p>拷贝不可变对象：只是增加一个指向原对象的引用，改变会互相影响。</p>
<p>拷贝可变对象(一层结构)：产生新的对象，开辟新的内存空间，改变互不影响。</p>
<p>拷贝可变对象(多层结构)：产生新的对象，开辟新的内存空间，不改变包含的子对象则互不影响、改变包含的子对象则互相影响。</p>
<h4 id="值传递引用传递"><a href="#值传递引用传递" class="headerlink" title="值传递引用传递"></a>值传递引用传递</h4><p>传值：是把实参的值赋给形参，修改形参，不会影响实参</p>
<p>传引用：以地址的方式传递参数，形参实参都是一个对象</p>
<p>于是就将传递<strong>不可变数据</strong>称为<strong>传值</strong>，传递<strong>可变数据</strong>称为<strong>传引用</strong></p>
<h4 id="形参实参"><a href="#形参实参" class="headerlink" title="形参实参"></a>形参实参</h4><p>形参是声明函数时定义的，多个形参用逗号隔开，需要与传入的实参一一对应。</p>
<p>实参是在调用时，实际传入函数中的值。</p>
<h4 id="不定长参数"><a href="#不定长参数" class="headerlink" title="不定长参数"></a>不定长参数</h4><p>在声明函数时，若不确定需要接收多少实参，就可以使用不j’j’j’j’j’j’j’j’j’j’j’j’j’j’j’j’j’j’j典</p>
<p>*args接收单个出现的参数，接收后存为元组</p>
<p>**kwargs接收以键值对形式出现的参数，接收后存为一个字典</p>
<h4 id="多任务概念、目的"><a href="#多任务概念、目的" class="headerlink" title="多任务概念、目的"></a>多任务概念、目的</h4><p>目的：充分利用CPU资源，提高程序的执行效率</p>
<p>例子：一边在用浏览器上网，一边在听网易云，一边再用typora写博客，这就是多任务，至少同时有3个任务正在运行。</p>
<h4 id="进程"><a href="#进程" class="headerlink" title="进程"></a>进程</h4><p>进程是CPU资源分配的最小单位，是正在运行的程序的实例</p>
<p><strong>特点</strong></p>
<p>独立性：每个进程都有都有独立的代码和数据空间（程序上下文），因此它们之间的资源分配和调度也相互独立（也就是常说的进程间彼此独立）。</p>
<p>动态性：程序只是一个静态的指令集合，而进程是程序运行的动态实例。</p>
<p>并发性：同时运行多个进程，能够最大化利用多核CPU的资源，提升运行速度。</p>
<h4 id="线程"><a href="#线程" class="headerlink" title="线程"></a>线程</h4><p>线程是cpu调度的最小单位。它被包含在进程之中，是进程中的实际运作单位</p>
<p><strong>注意点</strong></p>
<p>线程是进程的组成部分，一个线程必须有一个父进程，一个进程可以拥有多个线程</p>
<p>多线程之间共享资源，同时也会产生资源竞争问题</p>
<p>线程的执行是无序的，是 CPU 进行调度的</p>
<p><strong>多线程</strong></p>
<p>同时执行多个不同程序</p>
<p>例子：一家超市中同时有多个收银台在工作</p>
<p><strong>join阻塞</strong></p>
<p>主线程等待子线程执行完毕才退出（超市关门需要等顾客离开）</p>
<p><strong>守护线程</strong></p>
<p>主线程退出时，需要子线程随主线程一起退出（超市关门不等顾客离开）</p>
<p><strong>解决资源竞争</strong></p>
<p>线程同步：先执行哪个线程，再执行哪个线程，使用 join() 方法实现。（同步就是按照你事先定义好的顺序）</p>
<p>互斥锁：python 提供的一种机制，同一时刻只有一个线程，能够获得这把锁</p>
<p><strong>死锁</strong></p>
<p>在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。</p>
<h4 id="线程池和进程池的意义"><a href="#线程池和进程池的意义" class="headerlink" title="线程池和进程池的意义"></a>线程池和进程池的意义</h4><p>池的概念在于，预先创建好一定数量的线程</p>
<p>可以不需要重复创建，避免频繁的<strong>生产</strong>和<strong>释放</strong>线程资源导致的系统<strong>浪费资源</strong></p>
<p>白话：线程池就是管理线程的池子，当有任务要处理时，不用频繁创建新线程，而是从池子里拿个线程出来处理。当任务执行完，线程并不会被销毁，而是再等待下一个任务。因此可以节省资源，提高响应速度。</p>
<h4 id="数据库连接池"><a href="#数据库连接池" class="headerlink" title="数据库连接池"></a>数据库连接池</h4><p>python编程中可以使用pymysql进行数据库连接及增删改查操作，但每次连接mysql请求时，都是独立的去请求访问，比较浪费资源，而且访问数量达到一定数量时，对mysql的性能会产生较大的影响。因此实际使用中，通常会使用数据库的连接池技术，来访问数据库达到资源复用。</p>
<p>与线程池，进程池概念平移。都是为了达到资源服用</p>
<p>连接池对性能的提升：</p>
<ul>
<li>在程序创建连接的时候，可以从一个空闲的连接中获取，不需要重新初始化连接，提升获取连接的速度。</li>
<li>关闭连接的时候，把连接放回连接池，而不是真正的关闭，所以可以减少频繁的打开和关闭连接。</li>
</ul>
<h4 id="僵尸、孤儿进程"><a href="#僵尸、孤儿进程" class="headerlink" title="僵尸、孤儿进程"></a>僵尸、孤儿进程</h4><p>僵尸进程：当父进程开子进程后，子进程工作已经结束，但是父进程迟迟不去回收，这就会导致子进程陷入<strong>僵尸进程</strong>状态</p>
<p>危害：僵尸进程会一直占用PID等进程资源，无法释放进程控制块，导致新的进程无法使用。</p>
<p>孤儿进程：当父进程开启后，先于子进程退出，那么此时子线程没人回收，就造成了孤儿进程。</p>
<p>在linux操作系统下，有专门进行善后的孤儿院部门，也就是我们常说的init这个进程</p>
<h4 id="并发、并行"><a href="#并发、并行" class="headerlink" title="并发、并行"></a>并发、并行</h4><p>举个例子：假设你开了一个餐馆，只有一个厨师，但同时有两桌客人点了菜。简称A桌和B桌，为了让两桌客人都满意，你可以安排厨师，交叉地为两桌客人做菜。为A桌做一道菜，再为B桌做一道菜，如此交叉进行，直到做完所有的菜。这个只能叫并发，不能叫并行。如果你多雇一个厨师，两个厨师，一个做A桌的菜，一个做B桌的菜，这个就算并行了。</p>
<p>并发：一个时间段内，程序交替的去执行</p>
<p>并行：在多核 CPU 中，多个任务，在不同的 CPU 上，同时执行。</p>
<h4 id="cpu密集型-IO密集型"><a href="#cpu密集型-IO密集型" class="headerlink" title="cpu密集型/IO密集型"></a>cpu密集型/IO密集型</h4><p>cpu密集型也叫计算密集型，它的特点就是要进行大量的计算，消耗CPU资源，这个时候使用多进程</p>
<p>IO密集型，涉及到网络、磁盘IO的任务都是IO密集型任务，这类任务的特点是CPU消耗很少，使用多线程更为合适</p>
<h4 id="协程"><a href="#协程" class="headerlink" title="协程"></a>协程</h4><p>协程，又称微线程，纤程，协程是一种用户态的轻量级线程，用户态：具备自主意识，完全由用户控制。</p>
<p>线程在切换时会保存到CPU的栈里，协程拥有自己的上下文寄存器和栈</p>
<p>优缺点：</p>
<p>优：可以在io任务时进行切换，避免io阻塞造成资源浪费</p>
<p>缺：无法利用多核资源，因为协程的本质是单线程</p>
<p>说白了就是，当协程遇到io操作而阻塞时，立即切换到别的任务，如果操作完成则进行回调返回执行结果，提高了效率，同时这样也可以充分利用 CPU 和其他资源，这就是异步协程的优势，并且协程本质上是个单进程，相对于多进程来说，无需进程间上下文切换的开销，无需原子操作锁定及同步的开销，编程模型也非常简单。</p>
<p>举例子：在超市买苹果，用户需要10个apple，可是货架上只有5个，如果是同步思想的话，拿完5个apple，用户就会等待苹果上架（相当于程序阻塞），利用异步思想，货架空了，顾客可以选择去找店员补货（也就是切换出来执行别的操作）</p>
<p><strong>greenlet</strong></p>
<p>使用greenlet模块可以实现协程，这是一个由C扩展而来的用来实现协程的模块，但是需要通过switch来手动切换不同的代码块来运行协程</p>
<p><strong>gevent</strong></p>
<p>gevent可以使用gevent.spawn来创建一个协程，免去了手动切换协程的过程</p>
<p>使用gevent中的monkey补丁可以在协程遇到io操作堵塞时自动切换到其他协程</p>
<h4 id="迭代器生成器"><a href="#迭代器生成器" class="headerlink" title="迭代器生成器"></a>迭代器生成器</h4><p>迭代的概念：上一次输出的结果为下一次输入的初始值，重复的过程称为迭代,每次重复即一次迭代，并且每次迭代的结果是下一次迭代的初始值</p>
<p><strong>迭代器</strong></p>
<p>对于没有索引的数据类型，必须提供一种不依赖索引的迭代方式。</p>
<p>迭代器是访问集合内元素的一种方式，仅是一个容器对象，它有两个基本方法：next（返回容器的下一个元素），<strong>iter</strong>（返回迭代器本身）</p>
<p><strong>生成器</strong></p>
<p>生成器会生成一系列的值用于迭代，这样看它又是一种可迭代对象。它是在for循环的过程中不断计算出下一个元素，并在适当的条件结束for循环。</p>
<p>生成器内部实现了迭代器协议，并且支持延迟操作，所谓的延迟操作，就是在我需要的时候才会产生结果，而不是立即产生结果。举个例子，用列表推导式创建一个有100万元素的列表，它会占用很大的内存，如果我们只需要访问前几个元素的话，那后面的元素更是浪费了，这个时候生成器就可以帮我们很好的解决问题，哪怕是100万个元素，它调用一次也只会返回一个结果，这就是延迟操作。</p>
<p>生成器实现方式：</p>
<ul>
<li>生成器函数：定义形式跟普通函数一样，只是常规的函数中的return会立刻返回结果退出函数，而yield语句可以返回多次值，每次返回都会将函数暂停，下一次next会从上一次暂停的位置继续执行</li>
<li>生成器推导式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表</li>
</ul>
<h3 id="函数式编程"><a href="#函数式编程" class="headerlink" title="函数式编程"></a>函数式编程</h3><p>函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。</p>
<p>而函数式编程——Functional Programming，虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算。</p>
<h3 id="面向过程"><a href="#面向过程" class="headerlink" title="面向过程"></a>面向过程</h3><p>分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了</p>
<h3 id="面向对象-1"><a href="#面向对象-1" class="headerlink" title="面向对象"></a>面向对象</h3><p><strong>封装</strong>：将有共同的属性和方法封装到同一个类下面，就像生活中的衣物归纳整理</p>
<p><strong>继承</strong>：子类可以继承父类的属性和方法，实现代码重用</p>
<p><strong>多态</strong>：python天生是支持多态的，指的是基类的同一个方法在不同的派生类中有着不同的功能</p>
<h3 id="类方法、静态方法、实例方法"><a href="#类方法、静态方法、实例方法" class="headerlink" title="类方法、静态方法、实例方法"></a>类方法、静态方法、实例方法</h3><ol>
<li><p>定义形式：</p>
<p>a. 类方法和静态方法都需要通过装饰器来实现，实例方法不需要</p>
<p>b. 实例方法需要传入self参数，类方法需要cls参数，而静态方法无需参数也可以</p>
</li>
<li><p>调用方式：</p>
<p>a. 实例方法只能通过实例化对象调用</p>
</li>
</ol>

      
    </div><!-- .entry-content -->

    <footer class="entry-meta">
    <a href="/tefuir/2021/04/26/python%E5%9F%BA%E7%A1%80%E7%90%86%E8%AE%BA%E5%AE%9D%E5%85%B8/">
    <time datetime="2021-04-26T01:38:33.000Z" class="entry-date">
        2021-04-26
    </time>
</a>
    
    
    </footer>
</article>


    
<nav class="nav-single">
    <h3 class="assistive-text">文章导航</h3>
    
    
        <span class="nav-next"><a href="/tefuir/2021/04/23/python3-Flask%E7%BB%93%E5%90%88Socket-io%E7%AE%80%E5%8D%95%E5%AE%9E%E7%8E%B0%E5%9C%A8%E7%BA%BF%E5%AE%A2%E6%9C%8D%E7%B3%BB%E7%BB%9F/" rel="next">python3+Flask结合Socket.io简单实现在线客服系统 <span class="meta-nav">→</span></a></span>
    
</nav><!-- .nav-single -->







</div></div>
        <div id="secondary" class="widget-area" role="complementary">
  
    <aside id="search" class="widget widget_search"><form role="search" method="get" accept-charset="utf-8" id="searchform" class="searchform" action="//google.com/search">
    <div>
        <input type="text" value="" name="s" id="s" />
        <input type="submit" id="searchsubmit" value="搜索" />
    </div>
</form></aside>
  
    
  
    
  
    
  <aside class="widget">
    <h3 class="widget-title">Recents</h3>
    <div class="widget-content">
      <ul>
        
          <li>
            <a href="/tefuir/2021/04/26/python%E5%9F%BA%E7%A1%80%E7%90%86%E8%AE%BA%E5%AE%9D%E5%85%B8/">python基础理论宝典</a>
          </li>
        
          <li>
            <a href="/tefuir/2021/04/23/python3-Flask%E7%BB%93%E5%90%88Socket-io%E7%AE%80%E5%8D%95%E5%AE%9E%E7%8E%B0%E5%9C%A8%E7%BA%BF%E5%AE%A2%E6%9C%8D%E7%B3%BB%E7%BB%9F/">python3+Flask结合Socket.io简单实现在线客服系统</a>
          </li>
        
          <li>
            <a href="/tefuir/2021/04/23/win10%E7%B3%BB%E7%BB%9F%E4%B8%8B%E5%88%A9%E7%94%A8docker%E9%83%A8%E7%BD%B2gunicorn-Flask%E6%89%93%E9%80%A0%E7%8B%AC%E7%AB%8B%E9%95%9C%E5%83%8F/">win10系统下利用docker部署gunicorn+Flask打造独立镜像</a>
          </li>
        
          <li>
            <a href="/tefuir/2021/04/23/win10%E7%B3%BB%E7%BB%9F%E4%B8%8B%E5%9F%BA%E4%BA%8Edocker%E9%85%8D%E7%BD%AEelasticsearch%E9%85%8D%E5%90%88python3%E8%BF%9B%E8%A1%8C%E5%85%A8%E6%96%87%E6%A3%80%E7%B4%A2/">win10系统下基于docker配置elasticsearch配合python3进行全文检索</a>
          </li>
        
          <li>
            <a href="/tefuir/2021/04/23/%E6%9C%8D%E5%8A%A1%E5%99%A8%E9%97%AE%E9%A2%98/">服务器问题</a>
          </li>
        
      </ul>
    </div>
  </aside>

  
    
  
    
  
</div>
      </div>
      <footer id="colophon" role="contentinfo">
    <p>&copy; 2021 南辞
    All rights reserved.</p>
    <p>Powered by <a href="http://hexo.io/" target="_blank">Hexo</a></p>
</footer>
    <script>window._bd_share_config={"common":{"bdSnsKey":{},"bdText":"","bdMini":"1","bdMiniList":false,"bdPic":"","bdStyle":"2","bdSize":"16"},"share":{}};with(document)0[(getElementsByTagName('head')[0]||body).appendChild(createElement('script')).src='/js/share.js'];</script>

<script src="/js/jquery-3.3.1.min.js"></script>


  
<link rel="stylesheet" href="/tefuir/fancybox/jquery.fancybox.css">

  
<script src="/tefuir/fancybox/jquery.fancybox.pack.js"></script>




<script src="/tefuir/js/script.js"></script>


<script src="/js/navigation.js"></script>

<div id="bg"></div>

  </div>
</body>
</html>